home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 3 / Info_Mac_1994-01.iso / Graphics / Utility / GL Viewer 1.1.1 / src ƒ / exec.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-06  |  60.8 KB  |  3,783 lines  |  [TEXT/KAHL]
  1. /*
  2.  * Mac hack of
  3.  * exec.c - grasp language execution routines.
  4.  *
  5.  * Copyright (c) 1991 by Patrick J. Naughton
  6.  */
  7.  
  8. #pragma segment Exec
  9.  
  10. #include <math.h>
  11. #include "glassert.h"
  12. #include "grasp.h"
  13. #include "fades.h"
  14. #include "procImage.h"
  15. #define __INSTANTIATE__
  16. #include "exec.h"
  17.  
  18.  
  19. extern void error (...);
  20.  
  21. void printexec (ExecStruct *ex, int nargs);
  22.  
  23.  
  24. #define EXEC_ERROR()            \
  25. {                    \
  26.     extern Bool    aboutdone;        \
  27.                     \
  28.                     \
  29.     printexec (ex, nargs);        \
  30.     aboutdone = True;            \
  31.     error ("%s: argcount mismatch\n");    \
  32. }
  33.  
  34.  
  35. #define UNIMPLEMENTED  1
  36.  
  37. #define ESCAPE    -3
  38. #define DONE    -2
  39. #define CONT    -1
  40.  
  41. #define intarg(ex,index) (ex)->Code[(index)].val.i
  42. #define strarg(ex,index) (ex)->Code[(index)].val.s
  43. #define imgarg(ex,index) (ex)->Code[(index)].val.image
  44. #define fntarg(ex,index) (ex)->Code[(index)].val.font
  45. #define excarg(ex,index) (ex)->Code[(index)].val.exec
  46.  
  47. Colormap    EGAcmap = (Colormap) 0;
  48.  
  49. XRectangle  window = { 0, 0, 0, 0 };
  50.  
  51. typedef struct {
  52.     int         count;
  53.     int         ipaddr;
  54. }           stackent;
  55. #define STACKSIZE 16
  56.  
  57. stackent    loopstack[STACKSIZE];
  58. int         loopstackptr = 0;
  59.  
  60. int         ipstack[STACKSIZE];
  61. int         ipstackptr = 0;
  62.  
  63. ImageStruct *clipreg[128];
  64. FontStruct *fontreg[16];
  65. FontStruct *currentfont = 0;
  66. int         fstyle = 0;
  67. int         chargap = 1;
  68. int         spacegap = -1;
  69. int         currentcolor = 1;
  70. int         currentbgcolor = 0;
  71. Colormap    installedcmap = (Colormap) NULL;
  72. u_short     palettenum = 0;
  73. int         tranval = -1;
  74. int         keypressed = -1;
  75. int         videomode;
  76.  
  77. static short    xOffset = 0;
  78. static short    yOffset = 0;
  79.  
  80. static u_short    lastRegnum = -1;    /* index of last PLOADed image */
  81.  
  82.  
  83.     void
  84. InitExec (void)
  85.  
  86. {
  87.     u_short    i;
  88.  
  89.  
  90.     for (i = 0; i < PICREGSIZE; i++)
  91.         picreg[i] = (ImageStruct *) NULL;
  92.  
  93.     for (i = 0; i < 128; i++)
  94.         clipreg[i] = (ImageStruct *) NULL;
  95.  
  96.     for (i = 0; i < 16; i++)
  97.     fontreg[i] = (FontStruct *) NULL;
  98. }
  99.  
  100. void
  101. exitcheck()
  102. {
  103.     SystemTask ();
  104.  
  105.     if (FrontWindow () != (WindowPtr) dsp)
  106.     SelectWindow ((WindowPtr) dsp);
  107.  
  108.     if (StopKey()) XExit(0);
  109. }
  110.  
  111. /*
  112.  * delay sleeps for 'd'/100'ths of a second
  113.  * usleep() will have to be provided on non-sun platforms.
  114.  */
  115. void
  116. delay(d)
  117.     int         d;
  118. {
  119.     long    endtime = hundredthsofseconds() + d;
  120.     int        i,hos;
  121.  
  122.     while (1) {
  123.     exitcheck();
  124.     usleep(10000);  //<< BAD    /* sleep for 1/100th of a second */
  125.     if (hundredthsofseconds() > endtime)
  126.         return;
  127.     }
  128. }
  129.  
  130.  
  131. /*
  132.  * if ip is pointing at a wildcard '*' then resolvewild returns a pointer
  133.  * to the object which is referenced by the current data pointer.
  134.  * otherwise it checks the type of the ip to make sure it matches what
  135.  * the caller expected, plus a little hack for zero's mistyped as oh's.
  136.  */
  137. void       *
  138. resolvewild(ex, ip, type)
  139.     ExecStruct *ex;
  140.     int         ip;
  141.     int         type;
  142. {
  143.     int         i;
  144.  
  145.     if (ex->Code[ip].token == WILDTYPE) {
  146.     if (ex->currentdataptr == -1)
  147.         error("%s: resolvewild no data\n");
  148.     i = ex->currentdataptr++;
  149.     } else {
  150.     i = ip;
  151.     if (ex->Code[i].token != type) {
  152.         /* hack for mistyped zero's as Oh's */
  153.         if (ex->Code[i].token == STRING && ex->Code[i].val.s[0] == 'o') {
  154.         ex->Code[i].token = INTEGER;
  155.         ex->Code[i].val.i = 0;
  156.         } else
  157.         error("%s: resolvewild type mismatch.\n");
  158.     }
  159.     }
  160.  
  161.     switch (type) {
  162.     case STRING:
  163.     return (void *) ex->Code[i].val.s;
  164.     break;
  165.     case INTEGER:
  166.     return (void *) ex->Code[i].val.i;
  167.     break;
  168.     case IMAGE:
  169.     if (ex->Code[i].token == STRING)
  170.         stringtoimage(i, EXT_CLP);
  171.     return (void *) ex->Code[i].val.image;
  172.     break;
  173.     case FONTTYPE:
  174.     if (ex->Code[i].token == STRING)
  175.         stringtofont(i);
  176.     return (void *) ex->Code[i].val.font;
  177.     break;
  178.     default:
  179.     error("%s: resolvewild type failure\n");
  180.     }
  181. }
  182.  
  183. /*
  184.  * installs the colormap associated with the image argument.
  185.  */
  186. void
  187. installcmap(i)
  188. {
  189.     ImageStruct *im;
  190.  
  191.     palettenum = i;
  192.  
  193.     assert (palettenum < PICREGSIZE);
  194.  
  195.     im = picreg[i];
  196.     if (im) {
  197.     if ((installedcmap = im->cmap) /* != (Colormap) NULL */)
  198.         XSetWindowColormap(dsp, win, im->cmap);
  199.     else
  200.         fprintf (stderr, "installcmap (): no colormap for image at %d\n", i);
  201.     } else {
  202.     fprintf(stderr,"installcmap (): no image at %d\n", i);
  203.     installedcmap = (Colormap) 0;
  204.     }
  205. }
  206.  
  207. void
  208. setvideomode (int c)    /* from "(char c)" declaration.  THINK C 5.0.4 bug when        */
  209.             /* externally declared and used: char not promoted to int.  :(    */
  210.  
  211. {
  212.     int         w = 0;
  213.     int        h = 0;
  214.  
  215.  
  216.     if (c >= 'A' && c <= 'Z')
  217.     c += 'a' - 'A';
  218.  
  219.     if (EGAcmap == (Colormap) 0)
  220.     EGAcmap = CreateEGAcmap();
  221.  
  222.     videomode = c;
  223.     switch (c)
  224.     {
  225.     case '1':    /* 80x25 text 16 color */
  226.     w = 80 * 8;
  227.     h = 25 * 13 + 4;
  228.     installedcmap = (Colormap) 0;
  229.     palettenum = 0;
  230.     XSetWindowColormap(dsp, win, EGAcmap);
  231.     break;
  232.     case 'a':    /* 320x200 4 color */
  233.     w = 320;
  234.     h = 200;
  235.     break;
  236.     case 'c':    /* 640x200 2 color */
  237.     w = 640;
  238.     h = 400;
  239.     break;
  240.     case 'e':    /* 640x350 2 color */
  241.     w = 640;
  242.     h = 350;
  243.     break;
  244.     case 'g':    /* 640x350 16 colors */
  245.     w = 640;
  246.     h = 350;
  247.     break;
  248.     case 'h':    /* 720x384 2 colors */
  249.     w = 720;
  250.     h = 384;
  251.     break;
  252.     case 'i':    /* 640x350 16 colors */
  253.     w = 640;
  254.     h = 350;
  255.     break;
  256.     case 'j':    /* 640x480 16 colors */
  257.     w = 640;
  258.     h = 480;
  259.     break;
  260.     case 'k':    /* 640x350 16 colors */
  261.     w = 640;
  262.     h = 350;
  263.     break;
  264.     default:
  265.         fprintf (stderr, "Unrecognized video mode '%c'; using default.\n", c);
  266.     case 'l':    /* 320x200 256 color */
  267.     w = 320;
  268.     h = 200;
  269.     break;
  270.     case 'm':    /* 640x480 256 color */
  271.     w = 640;
  272.     h = 480;
  273.     break;
  274.     case 'n':    /* 720x348 16 color */
  275.     w = 720;
  276.     h = 348;
  277.     break;
  278.     case 'o':    /* 640x480 2 color */
  279.     w = 640;
  280.     h = 480;
  281.     break;
  282.     case 'p':    /* 800x600 2 color */
  283.     w = 800;
  284.     h = 600;
  285.     break;
  286.     case 'q':    /* 800x600 16 color */
  287.     w = 800;
  288.     h = 600;
  289.     break;
  290.     case 'r':    /* 800x600 256 color */
  291.     w = 640;
  292.     h = 350;
  293.     break;
  294.     case 's':    /* 800x600 256 color */
  295.     w = 640;
  296.     h = 480;
  297.     break;
  298.     case 't':    /* 800x600 256 color */
  299.     w = 800;
  300.     h = 600;
  301.     break;
  302.     case 'w':    /* 360x480 256 color */
  303.     w = 360;
  304.     h = 480;
  305.     break;
  306.  
  307.     case '?':    /* maximum dimensions of all loaded images */
  308.     {
  309.     u_short    i;
  310.  
  311.  
  312.     w = 0;
  313.     h = 0;
  314.  
  315.     for (i = 0; i < PICREGSIZE; i++)
  316.     {
  317.         ImageStruct    *pIm = picreg[i];
  318.  
  319.  
  320.         if (pIm /* != (ImageStruct *) NULL */)
  321.         {
  322.             if (pIm->w > w)
  323.             w = pIm->w;
  324.             if (pIm->h > h)
  325.             h = pIm->h;
  326.         }
  327.     }
  328.  
  329.     if (verbose)
  330.     {
  331.         fprintf (stderr, "Max window size: %dx%d (0x%lx)\n", w, h, picreg[0]);
  332.         fflush (stderr);
  333.     }
  334.  
  335.     if (w == 0 || h == 0)
  336.         return;
  337.  
  338.         break;
  339.     }
  340.     }
  341.  
  342.     AdjustBackgroundPic (w, h);
  343. }
  344.  
  345.  
  346.     void
  347. AdjustBackgroundPic (int w, int h)
  348.  
  349. {
  350.     if (picreg[0] == (ImageStruct *) NULL ||
  351.         picreg[0]->w != w || picreg[0]->h != h)
  352.     {
  353.     if (picreg[0] /* != (ImageStruct *) NULL */)
  354.     {
  355.         XFreePixmap(dsp, picreg[0]->pix);
  356.         if (picreg[0]->cmap)
  357.         XFreeColormap(dsp, picreg[0]->cmap);
  358.         free(picreg[0]);
  359.     }
  360.  
  361.     picreg[0] = (ImageStruct *) malloc((size_t) sizeof(ImageStruct));
  362.     assert (picreg[0]);
  363.     picreg[0]->name = "background";
  364.     picreg[0]->type = EXT_PIC;
  365.     picreg[0]->w = w;
  366.     picreg[0]->h = h;
  367.     picreg[0]->d = 8;
  368.     picreg[0]->xoff = 0;
  369.     picreg[0]->yoff = 0;
  370.     picreg[0]->pix = XCreatePixmap(dsp, win, w, h, 8);
  371.     XSetForeground(dsp, gc, 0);
  372.     XFillRectangle(dsp, picreg[0]->pix, gc, 0, 0, w, h);
  373.     picreg[0]->cmap = (Colormap) 0;
  374.     picreg[0]->cmaplen = 0;
  375.  
  376.     XResizeWindow (dsp, win, w, h);
  377.     }
  378.  
  379.     window.x = window.y = 0;
  380.     window.width = w;
  381.     window.height = h;
  382.  
  383.     {
  384.         Rect    aRect;
  385.         GrafPtr    oldPort;
  386.  
  387.  
  388.     GetPort (&oldPort);
  389.     SetPort ((WindowPtr) dsp);
  390.         SetRect (&aRect, 0, 0, w, h);
  391.         FillRect (&aRect, white);
  392.     SetPort (oldPort);    
  393.     }
  394.  
  395.      XSync (dsp, False);
  396. }
  397.  
  398.  
  399. int
  400. unimplemented(ex, ip)
  401.     ExecStruct *ex;
  402.     int         ip;
  403. {
  404.     fprintf(stderr,"%s: ", tokens[ex->Code[ip - 1].token]);
  405.     fprintf(stderr,"unimplemented operator.\n");
  406.     return CONT;
  407. }
  408.  
  409. #define defrect(r, X, Y, W, H) \
  410.     (r).x = X, (r).y = Y, (r).width = W, (r).height = H
  411.  
  412. void
  413. drawWideRect(dpy, win, gc, x, y, w, h, thick)
  414.     Display    *dpy;
  415.     Window      win;
  416.     GC          gc;
  417.     int         x, y, w, h;
  418.     int         thick;
  419. {
  420.     XRectangle  rects[4];
  421.     int         nrects, doublethick;
  422.  
  423.     if (w == 0 && h == 0)
  424.     return;
  425.  
  426.     doublethick = 2 * thick;
  427.  
  428.     // if too small for box just draw one solid rect
  429.  
  430.     if (w <= doublethick || h <= doublethick) {
  431.     defrect(rects[0], x, y, w, h);
  432.     nrects = 1;
  433.     // else draw all 4 rects for the box
  434.     } else {
  435.     defrect(rects[0], x, y, w, thick);
  436.     defrect(rects[1], x, y + h - thick, w, thick);
  437.     defrect(rects[2], x, y + thick, thick, h - doublethick);
  438.     defrect(rects[3], x + w - thick, y + thick, thick, h - doublethick);
  439.     nrects = 4;
  440.     }
  441.     XFillRectangles(dpy, win, gc, rects, nrects);
  442. }
  443.  
  444.  
  445. /*-
  446.  * BOX x1 y1 x2 y2 [thickness]
  447.  * draws a hollow rectangle in the current color as thick as specified.
  448.  */
  449.  
  450. int
  451. f_box(ex, ip, nargs)
  452.     ExecStruct *ex;
  453.     int         ip;
  454.     int         nargs;
  455. {
  456.     int         x1;
  457.     int         y1;
  458.     int         x2;
  459.     int         y2;
  460.     int         th;
  461.  
  462.     switch (nargs) {
  463.     default:
  464.     case 5:
  465.     th = intarg(ex, ip + 4);
  466.     break;
  467.     case 4:
  468.     th = 1;
  469.     break;
  470.     case 0:
  471.     EXEC_ERROR ();
  472.     break;
  473.     }
  474.  
  475.     x1 = intarg(ex, ip);
  476.     y1 = intarg(ex, ip + 1);
  477.     x2 = intarg(ex, ip + 2);
  478.     y2 = intarg(ex, ip + 3);
  479.  
  480.     XSetForeground(dsp, gc, currentcolor);
  481.     drawWideRect(dsp, win, gc, x1, YFLIP(y2), x2 - x1, y2 - y1, th);
  482.  
  483.     return CONT;
  484. }
  485.  
  486. /*-
  487.  * BREAK label
  488.  * break out of a loop.
  489.  */
  490. int
  491. f_break(ex, ip, nargs)
  492.     ExecStruct *ex;
  493.     int         ip;
  494.     int         nargs;
  495. {
  496. #ifdef UNIMPLEMENTED
  497.     switch (nargs) {
  498.     default:
  499.     case 1:
  500.     break;
  501.     case 0:
  502.     EXEC_ERROR ();
  503.     break;
  504.     }
  505. #endif
  506.  
  507.     return unimplemented(ex, ip);
  508. }
  509.  
  510.  
  511. /*-
  512.  * CALL file [label]
  513.  */
  514. int
  515. f_call(ex, ip, nargs)
  516.     ExecStruct *ex;
  517.     int         ip;
  518.     int         nargs;
  519. {
  520.     void        execfile();
  521.     int         label;
  522.  
  523.     switch (nargs) {
  524.     default:
  525.     case 2:
  526.     label = intarg(ex, ip + 1);
  527.     break;
  528.     case 1:
  529.     label = 0;
  530.     break;
  531.     case 0:
  532.     EXEC_ERROR ();
  533.     break;
  534.     }
  535.  
  536.     execfile(excarg(ex, ip), label);
  537.  
  538.     return CONT;
  539. }
  540.  
  541. /*-
  542.  * CFADE fadenumber x y [buffernumber] [speed] [delay]
  543.  * fade the given buffer using the given fade number at x,y.
  544.  */
  545. int
  546. f_cfade(ex, ip, nargs)
  547.     ExecStruct *ex;
  548.     int         ip;
  549.     int         nargs;
  550. {
  551.     int         fadestyle;
  552.     int         x;
  553.     int         y;
  554.     u_short     buf = 1;
  555.     int         speed = 0;
  556.     int         d = 10;
  557.     ImageStruct *im;
  558.  
  559.  
  560.     switch (nargs) {
  561.     default:
  562.     case 6:
  563.     d         = intarg(ex, ip + 5);
  564.     case 5:
  565.     speed     = intarg(ex, ip + 4);
  566.     case 4:
  567.     buf       = intarg(ex, ip + 3);
  568.     case 3:
  569.     y         = intarg(ex, ip + 2);
  570.     x         = intarg(ex, ip + 1);
  571.     fadestyle = intarg(ex, ip);
  572.     break;
  573.     case 0:
  574.     case 1:
  575.     case 2:
  576.     EXEC_ERROR ();
  577.     break;
  578.     }
  579.  
  580.     assert (buf < 128);
  581.  
  582.     assert (im = clipreg[buf] /* != (ImageStruct *) NULL */);
  583.  
  584.     imagefade(fadestyle, im,
  585.     x + im->xoff, YFLIPIM(y, im) + im->yoff, speed, 0);
  586.  
  587.     delay(d);
  588.  
  589.     return CONT;
  590. }
  591.  
  592. /*-
  593.  * CFREE buffer [buffer] ...
  594.  * unload a clipping
  595.  */
  596. int
  597. f_cfree(ex, ip, nargs)
  598.     ExecStruct *ex;
  599.     int         ip;
  600.     int         nargs;
  601. {
  602. #ifdef UNIMPLEMENTED
  603.     switch (nargs) {
  604.     case 0:
  605.     EXEC_ERROR ();
  606.     break;
  607.     default:
  608.     break;
  609.     }
  610. #endif
  611.  
  612.     /* NOP */
  613.     return CONT;
  614. }
  615.  
  616. /*-
  617.  * CGETBUF n [x1 y1 x2 y2] [noshift] [tran]
  618.  * copy an area of the screen into a clip buffer
  619.  */
  620. int
  621. f_cgetbuf(ex, ip, nargs)
  622.     ExecStruct *ex;
  623.     int         ip;
  624.     int         nargs;
  625. {
  626.     u_short     clip;
  627.     int         x1;
  628.     int         y1;
  629.     int         x2;
  630.     int         y2;
  631.     ImageStruct *im;
  632.     XImage     *xim;
  633.  
  634.     switch (nargs){
  635.     default:
  636.     case 7:
  637.     case 6:
  638.     case 5:
  639.     y2 = intarg(ex, ip + 4);
  640.     x2 = intarg(ex, ip + 3);
  641.     y1 = intarg(ex, ip + 2);
  642.     x1 = intarg(ex, ip + 1);
  643.     case 1:
  644.     clip = intarg(ex, ip);
  645.     break;
  646.     case 0:
  647.     case 2:
  648.     case 3:
  649.     case 4:
  650.     EXEC_ERROR ();
  651.     break;
  652.     }
  653.  
  654.     im = (ImageStruct *) malloc((size_t) sizeof(ImageStruct));
  655.     assert (im);
  656.     im->name = "getbuf";
  657.     im->w = x2 - x1;
  658.     im->h = y2 - y1;
  659.     im->d = 8;
  660.     im->cmap = (Colormap) 0;
  661.     im->cmaplen = 0;
  662.     im->pix = XCreatePixmap(dsp, win, im->w, im->h, 8);
  663.  
  664.     assert (clip < 128);
  665.     clipreg[clip] = im;
  666.  
  667. //    xim = XGetImage(dsp, win, x1, y1, im->w, im->h, 0xff, ZPixmap);
  668. //    XPutImage(dsp, im->pix, gc, xim, 0, 0, 0, 0, im->w, im->h);
  669. //    free(xim->data);
  670. //    free(xim);
  671.  
  672.     return CONT;
  673. }
  674.  
  675. /*-
  676.  * CHGCOLOR slot val [slot val] ...
  677.  * change palette colors in EGA mode.
  678.  */
  679. int
  680. f_chgcolor(ex, ip, nargs)
  681.     ExecStruct *ex;
  682.     int         ip;
  683.     int         nargs;
  684. {
  685.     int         i;
  686.     u_long      pmasks;
  687.     u_long      pixels[16];
  688.     ImageStruct *im = picreg[0];
  689.  
  690.  
  691.     assert (im);
  692.  
  693.     switch (nargs) {
  694.     case 0:
  695.     EXEC_ERROR ();
  696.     break;
  697.     default:
  698.     switch (nargs % 2) {
  699.     case 1:
  700.         EXEC_ERROR ();
  701.         break;
  702.     default:
  703.         break;
  704.     }
  705.     break;
  706.     }
  707.  
  708.     im->cmaplen = 16;    /* EGA hard-coded value */
  709.     if (!im->cmap) {
  710.     im->cmap = XCreateColormap(dsp, win, vis, AllocNone);
  711.     XAllocColorCells(dsp, im->cmap, True, (unsigned long *) &pmasks,
  712.                      0, (unsigned long *) pixels, im->cmaplen);
  713.     }
  714.  
  715.     for (i = 0; i < nargs; i += 2) {
  716.     int         slot = intarg(ex, ip + i);
  717.     int         pal = intarg(ex, ip + i + 1);
  718.  
  719.     im->colors[slot].pixel = slot;
  720.     im->colors[slot].red = decodepal(pal, 0x20, 0x04) << 8;
  721.     im->colors[slot].green = decodepal(pal, 0x10, 0x02) << 8;
  722.     im->colors[slot].blue = decodepal(pal, 0x08, 0x01) << 8;
  723.     im->colors[slot].flags = DoRed | DoGreen | DoBlue;
  724.  
  725. //    XStoreColor(dsp, im->cmap, &(im->colors[slot]));
  726.     }
  727.  
  728.     installcmap(0);
  729.  
  730.     return CONT;
  731. }
  732.  
  733. /*-
  734.  * CIRCLE x y xr [yr] [iris]
  735.  * draw an ellipse
  736.  */
  737. int
  738. f_circle(ex, ip, nargs)
  739.     ExecStruct *ex;
  740.     int         ip;
  741.     int         nargs;
  742. {
  743. #ifdef UNIMPLEMENTED
  744.     switch (nargs) {
  745.     default:
  746.     case 5:
  747.     case 4:
  748.     case 3:
  749.     break;
  750.     case 0:
  751.     case 1:
  752.     case 2:
  753.     EXEC_ERROR ();
  754.     break;
  755.     }
  756. #endif
  757.  
  758.     return unimplemented(ex, ip);
  759. }
  760.  
  761. /*-
  762.  * CLEARSCR
  763.  * paint entire screen
  764.  */
  765. int
  766. f_clearscr(ex, ip, nargs)
  767.     ExecStruct *ex;
  768.     int         ip;
  769.     int         nargs;
  770. {
  771. #if 0
  772.     switch (nargs) {
  773.     case 0:
  774.     break;
  775.     default:
  776.     EXEC_ERROR ();
  777.     break;
  778.     }
  779. #endif
  780.  
  781.     if (picreg[0] == 0)
  782.     setvideomode('l');
  783.     XSetForeground(dsp, gc, currentcolor);
  784.     if (picreg[0] /* != (ImageStruct *) NULL */)
  785.     {
  786.     XFillRectangle(dsp, picreg[0]->pix, gc,
  787.              0, 0, picreg[0]->w, picreg[0]->h);
  788.  
  789. //    XCopyArea(dsp, picreg[0]->pix, win, gc,
  790. //           0, 0, picreg[0]->w, picreg[0]->h, 0, 0);
  791.     }
  792.  
  793.     return CONT;
  794. }
  795.  
  796. /*-
  797.  * CLOAD name [buffer] [noshift] [tran]
  798.  * load a clipping
  799.  */
  800. int
  801. f_cload(ex, ip, nargs)
  802.     ExecStruct *ex;
  803.     int         ip;
  804.     int         nargs;
  805. {
  806.     u_short    clip;
  807.  
  808.     switch (nargs) {
  809.     default:
  810.     case 4:
  811.     case 3:
  812.     case 2:
  813.     clip = (u_short) resolvewild(ex, ip + 1, INTEGER);
  814.     break;
  815.     case 1:
  816.     clip = 0;
  817.     break;
  818.     case 0:
  819.     EXEC_ERROR ();
  820.     break;
  821.     }
  822.  
  823.     assert (clip < 128);
  824.     clipreg[clip] = (ImageStruct *) resolvewild(ex, ip, IMAGE);
  825.  
  826.     return CONT;
  827. }
  828.  
  829. /*-
  830.  * CLOSEGL
  831.  * close a library file
  832.  */
  833. int
  834. f_closegl(ex, ip, nargs)
  835.     ExecStruct *ex;
  836.     int         ip;
  837.     int         nargs;
  838. {
  839. #ifdef UNIMPLEMENTED
  840.     switch (nargs) {
  841.     case 0:
  842.     break;
  843. #if 0
  844.     default:
  845.     EXEC_ERROR ();
  846.     break;
  847. #endif
  848.     }
  849. #endif
  850.  
  851.     return unimplemented(ex, ip);
  852. }
  853.  
  854. /*-
  855.  * COLOR color1 [R] [color2]
  856.  * set the drawing color, (not sure what the R is...)
  857.  */
  858. int
  859. f_color(ex, ip, nargs)
  860.     ExecStruct *ex;
  861.     int         ip;
  862.     int         nargs;
  863. {
  864.  
  865.     switch (nargs) {
  866.     default:
  867.     case 2:
  868.     currentbgcolor = intarg(ex, ip + 1);
  869.     case 1:
  870.     currentcolor = intarg(ex, ip);
  871.     break;
  872.     case 0:
  873.     EXEC_ERROR ();
  874.     break;
  875.     }
  876.  
  877.     return CONT;
  878. }
  879.  
  880. /*-
  881.  * CYCLE cycles start number [time]
  882.  * rotate palette colors.
  883.  */
  884. int
  885. f_cycle(ex, ip, nargs)
  886.     ExecStruct *ex;
  887.     int         ip;
  888.     int         nargs;
  889. {
  890.     int         cycles;
  891.     int         start;
  892.     int         number;
  893.     int         d = 0;
  894.     int         i;
  895.     int         j;
  896.     int         end;
  897.     ImageStruct *pIm = picreg[palettenum];
  898.     XColor     *c;
  899.     unsigned long buffer;
  900.  
  901.  
  902.     assert (pIm);
  903.     assert (c = pIm->colors);
  904.  
  905.     switch (nargs) {
  906.     default:
  907.     case 4:
  908.     d = intarg(ex, ip + 3);
  909.     case 3:
  910.     number = intarg(ex, ip + 2);
  911.     start  = intarg(ex, ip + 1);
  912.     cycles = intarg(ex, ip);
  913.     break;
  914.     case 0:
  915.     case 1:
  916.     case 2:
  917.     EXEC_ERROR ();
  918.     break;
  919.     }
  920.  
  921.     end = start + number - 1;
  922.  
  923.     for (i = 0; i < cycles; i++) {
  924.      buffer = c[start].pixel;
  925.      for (j = start; j < end; j++)
  926.          c[j].pixel = c[j + 1].pixel;
  927.      c[end].pixel = buffer;
  928.      XStoreColors(dsp, installedcmap, &c[start], number);
  929.      XSync(dsp, False);
  930.     if (d)
  931.         delay(d);
  932.     }
  933.     return CONT;
  934. }
  935.  
  936. /*-
  937.  * DATA item [item] ...
  938.  * define data elements
  939.  */
  940. int
  941. f_data(ex, ip, nargs)
  942.     ExecStruct *ex;
  943.     int         ip;
  944.     int         nargs;
  945. {
  946.     switch (nargs) {
  947.     case 0:
  948.     EXEC_ERROR ();
  949.     break;
  950.     default:
  951.     break;
  952.     }
  953.  
  954.     ex->currentdataptr = ip;
  955.     return CONT;
  956. }
  957.  
  958. /*-
  959.  * DATABEGIN
  960.  * define data elements (multiple lines)
  961.  */
  962. int
  963. f_databegin(ex, ip, nargs)
  964.     ExecStruct *ex;
  965.     int         ip;
  966.     int         nargs;
  967. {
  968.     switch (nargs) {
  969.     case 1:
  970.     ex->currentdataptr = intarg(ex, ip);
  971.     break;
  972.     default:
  973.     ex->currentdataptr = ip;
  974.     break;
  975.     }
  976.  
  977.     return CONT;
  978. }
  979.  
  980. /*-
  981.  * DATAEND
  982.  * mark the end of a data block
  983.  */
  984. int
  985. f_dataend(ex, ip, nargs)
  986.     ExecStruct *ex;
  987.     int         ip;
  988.     int         nargs;
  989. {
  990.     switch (nargs) {
  991.     case 0:
  992.     break;
  993. #if 0
  994.     default:
  995.     EXEC_ERROR ();
  996.     break;
  997. #endif
  998.     }
  999.  
  1000.     ex->currentdataend = ip - 2;
  1001.     return CONT;
  1002. }
  1003.  
  1004. /*-
  1005.  * DATASKIP n
  1006.  * skip n data elements in a block.
  1007.  */
  1008. f_dataskip(ex, ip, nargs)
  1009.     ExecStruct *ex;
  1010.     int         ip;
  1011.     int         nargs;
  1012. {
  1013.     switch (nargs) {
  1014.     default:
  1015.     case 1:
  1016.     ex->currentdataptr += intarg(ex, ip);
  1017.     break;
  1018.     case 0:
  1019.     EXEC_ERROR ();
  1020.     break;
  1021.     }
  1022.  
  1023.     return unimplemented(ex, ip);
  1024. }
  1025.  
  1026. /*-
  1027.  * DFREE buffer [buffer] ...
  1028.  *
  1029.  */
  1030. int
  1031. f_dfree(ex, ip, nargs)
  1032.     ExecStruct *ex;
  1033.     int         ip;
  1034.     int         nargs;
  1035. {
  1036. #ifdef UNIMPLEMENTED
  1037.     switch (nargs) {
  1038.     case 0:
  1039.     EXEC_ERROR ();
  1040.     break;
  1041.     default:
  1042.     break;
  1043.     }
  1044. #endif
  1045.  
  1046.     return unimplemented(ex, ip);
  1047. }
  1048.  
  1049. /*-
  1050.  * DLOAD name [buffer] [disk]
  1051.  * load a differential animation file.
  1052.  */
  1053. int
  1054. f_dload(ex, ip, nargs)
  1055.     ExecStruct *ex;
  1056.     int         ip;
  1057.     int         nargs;
  1058. {
  1059. #ifdef UNIMPLEMENTED
  1060.     switch (nargs) {
  1061.     default:
  1062.     case 3:
  1063.     case 2:
  1064.     case 1:
  1065.     break;
  1066.     case 0:
  1067.     EXEC_ERROR ();
  1068.     break;
  1069.     }
  1070. #endif
  1071.  
  1072.     return unimplemented(ex, ip);
  1073. }
  1074.  
  1075. /*-
  1076.  * EDGE setting [color]
  1077.  * turn leading edge for fades on or off.
  1078.  */
  1079. int
  1080. f_edge(ex, ip, nargs)
  1081.     ExecStruct *ex;
  1082.     int         ip;
  1083.     int         nargs;
  1084. {
  1085. #ifdef UNIMPLEMENTED
  1086.     switch (nargs) {
  1087.     default:
  1088.     case 2:
  1089.     case 1:
  1090.     break;
  1091.     case 0:
  1092.     EXEC_ERROR ();
  1093.     break;
  1094.     }
  1095. #endif
  1096.  
  1097.     return unimplemented(ex, ip);
  1098. }
  1099.  
  1100. /*-
  1101.  * ELSE
  1102.  * target for IF condition not met.
  1103.  */
  1104. int
  1105. f_else(ex, ip, nargs)
  1106.     ExecStruct *ex;
  1107.     int         ip;
  1108.     int         nargs;
  1109. {
  1110. #ifdef UNIMPLEMENTED
  1111.     switch (nargs) {
  1112.     case 0:
  1113.     EXEC_ERROR ();
  1114.     break;
  1115.     default:
  1116.     break;
  1117.     }
  1118. #endif
  1119.  
  1120.     return unimplemented(ex, ip);
  1121. }
  1122.  
  1123. /*-
  1124.  * ENDLFLOAT
  1125.  * clear the float background buffer.
  1126.  */
  1127. int
  1128. f_endlfloat(ex, ip, nargs)
  1129.     ExecStruct *ex;
  1130.     int         ip;
  1131.     int         nargs;
  1132. {
  1133. #ifdef UNIMPLEMENTED
  1134.     switch (nargs) {
  1135.     case 0:
  1136.     EXEC_ERROR ();
  1137.     break;
  1138.     default:
  1139.     break;
  1140.     }
  1141. #endif
  1142.  
  1143.     return unimplemented(ex, ip);
  1144. }
  1145.  
  1146. /*-
  1147.  * ENDIF
  1148.  * mark the end of an if-else block
  1149.  */
  1150. int
  1151. f_endif(ex, ip, nargs)
  1152.     ExecStruct *ex;
  1153.     int         ip;
  1154.     int         nargs;
  1155. {
  1156. #ifdef UNIMPLEMENTED
  1157.     switch (nargs) {
  1158.     case 0:
  1159.     EXEC_ERROR ();
  1160.     break;
  1161.     default:
  1162.     break;
  1163.     }
  1164. #endif
  1165.  
  1166.     return unimplemented(ex, ip);
  1167. }
  1168.  
  1169. /*-
  1170.  * EXEC name [options]
  1171.  * run a non-grasp program.
  1172.  */
  1173. int
  1174. f_exec(ex, ip, nargs)
  1175.     ExecStruct *ex;
  1176.     int         ip;
  1177.     int         nargs;
  1178. {
  1179. #ifdef UNIMPLEMENTED
  1180.     switch (nargs) {
  1181.     default:
  1182.     case 2:
  1183.     case 1:
  1184.     break;
  1185.     case 0:
  1186.     EXEC_ERROR ();
  1187.     break;
  1188.     }
  1189. #endif
  1190.  
  1191.     return unimplemented(ex, ip);
  1192. }
  1193.  
  1194. /*-
  1195.  * EXIT [value]
  1196.  * exit grasp or subprogram.
  1197.  */
  1198. int
  1199. f_exit(ex, ip, nargs)
  1200.     ExecStruct *ex;
  1201.     int         ip;
  1202.     int         nargs;
  1203. {
  1204.     switch (nargs) {
  1205.     case 1:
  1206.     case 0:
  1207.     break;
  1208. #if 0
  1209.     default:
  1210.     EXEC_ERROR ();
  1211.     break;
  1212. #endif
  1213.     }
  1214.  
  1215.     delay(100);
  1216.     return DONE;
  1217. }
  1218.  
  1219. /*-
  1220.  * FFREE [buffer] ...
  1221.  * unload a font
  1222.  */
  1223. int
  1224. f_ffree(ex, ip, nargs)
  1225.     ExecStruct *ex;
  1226.     int         ip;
  1227.     int         nargs;
  1228. {
  1229. #ifdef UNIMPLEMENTED
  1230.     switch (nargs) {
  1231.     default:
  1232.     break;
  1233.     }
  1234. #endif
  1235.  
  1236.     /* NOP */
  1237.     return CONT;
  1238. }
  1239.  
  1240. /*-
  1241.  * FGAPS char [space]
  1242.  * set letter and word spacing
  1243.  */
  1244. int
  1245. f_fgaps(ex, ip, nargs)
  1246.     ExecStruct *ex;
  1247.     int         ip;
  1248.     int         nargs;
  1249. {
  1250.     switch (nargs) {
  1251.     default:
  1252.     case 2:
  1253.     spacegap = intarg(ex, ip + 1);
  1254.     case 1:
  1255.     chargap = intarg(ex, ip);
  1256.     break;
  1257.     case 0:
  1258.     EXEC_ERROR ();
  1259.     break;
  1260.     }
  1261.  
  1262.     return CONT;
  1263. }
  1264.  
  1265. /*-
  1266.  * FLOAD name [buffer]
  1267.  * load a font
  1268.  */
  1269. int
  1270. f_fload(ex, ip, nargs)
  1271.     ExecStruct *ex;
  1272.     int         ip;
  1273.     int         nargs;
  1274. {
  1275.     FontStruct *f;
  1276.     u_short     reg = 1;
  1277.  
  1278.     switch (nargs) {
  1279.     default:
  1280.     case 2:
  1281.     reg = intarg(ex, ip + 1);
  1282.     case 1:
  1283.     f = fntarg(ex, ip);
  1284.     break;
  1285.     case 0:
  1286.     EXEC_ERROR ();
  1287.     break;
  1288.     }
  1289.  
  1290.     assert (reg < 16);
  1291.     fontreg[reg] = f;
  1292.     currentfont = f;
  1293.  
  1294.     chargap = 1;
  1295.     spacegap = f->glyphs[' '].width;
  1296.  
  1297.     return CONT;
  1298. }
  1299.  
  1300. /*-
  1301.  * FLOAT x1 y1 x2 y2 step delay buf [buf] ...
  1302.  * animate a clipping and preserve the background.
  1303.  */
  1304. int
  1305. f_float(ex, ip, nargs)
  1306.     ExecStruct *ex;
  1307.     int         ip;
  1308.     int         nargs;
  1309. {
  1310.     u_short    ithImage;
  1311.     int         x1;
  1312.     int         y1;
  1313.     int         x2;
  1314.     int         y2;
  1315.     int         step;
  1316.     int         d;
  1317.     int         i;
  1318.     int         image;
  1319.     int         count;
  1320.     float       x;
  1321.     float       y;
  1322.     float       dx;
  1323.     float       dy;
  1324.     Window      floatwin;
  1325.     ImageStruct *im;
  1326.     XSetWindowAttributes xswa;
  1327.  
  1328.     switch (nargs) {
  1329.     case 6:
  1330.     case 5:
  1331.     case 4:
  1332.     case 3:
  1333.     case 2:
  1334.     case 1:
  1335.     case 0:
  1336.     EXEC_ERROR ();
  1337.     break;
  1338.     default:
  1339.     ithImage = intarg(ex, ip + 6);
  1340.     assert (ithImage < 128);
  1341.     im = clipreg[ithImage];
  1342.     assert (im);
  1343.     d = intarg(ex, ip + 5);
  1344.     step = intarg(ex, ip + 4);
  1345.     y2 = intarg(ex, ip + 3);
  1346.     x2 = intarg(ex, ip + 2);
  1347.     y1 = intarg(ex, ip + 1);
  1348.     x1 = intarg(ex, ip);
  1349.     break;
  1350.     }
  1351.  
  1352. //    xswa.backing_store = Always;
  1353.     floatwin = XCreateWindow(dsp, win, x1, YFLIPIM(y1, im), im->w, im->h, 0, 8,
  1354.               InputOutput, vis, CWBackingStore, &xswa);
  1355.     XCopyArea(dsp, im->pix, floatwin, gc, 0, 0, im->w, im->h, 0, 0);
  1356.     XMapWindow(dsp, floatwin);
  1357.  
  1358.     if (x1 == x2 && y1 == y2 ) {
  1359.     for (image = 7; image < nargs; image++) {
  1360.         u_short ithImage = intarg(ex, ip + image);
  1361.  
  1362.  
  1363.         assert (ithImage < 128);
  1364.         im = clipreg[ithImage];
  1365.         assert (im);
  1366.         XMoveResizeWindow(dsp, floatwin, x1, YFLIPIM(y1, im), im->w, im->h);
  1367.          XCopyArea(dsp, im->pix, floatwin, gc, 0, 0, im->w, im->h, 0, 0);
  1368.          XSync(dsp, False);
  1369.         delay(d);
  1370.     }
  1371.     } else {
  1372.     x = x1;
  1373.     y = y1;
  1374.     dx = (x2 - x1);
  1375.     dy = (y2 - y1);
  1376.     count = sqrt(dx * dx + dy * dy) / step;
  1377.     dx /= count;
  1378.     dy /= count;
  1379.     image = 7;
  1380.  
  1381.     for (i = 0; i <= count; i++) {
  1382.         if (nargs > 7) {
  1383.         u_short ithImage = intarg(ex, ip + image);
  1384.  
  1385.  
  1386.         assert (ithImage < 128);
  1387.         im = clipreg[ithImage];
  1388.         assert (im);
  1389.         if (++image == nargs)
  1390.             image = 6;
  1391.         }
  1392.          XMoveResizeWindow(dsp, floatwin, (int) x, YFLIPIM((int) y, im),
  1393.          im->w, im->h);
  1394.          XCopyArea(dsp, im->pix, floatwin, gc, 0, 0, im->w, im->h, 0, 0);
  1395.          XSync(dsp, False);
  1396.         x += dx;
  1397.         y += dy;
  1398.         delay(d);
  1399.     }
  1400.     }
  1401.  
  1402.     XUnmapWindow(dsp, floatwin);
  1403.     XDestroyWindow(dsp, floatwin);
  1404.     return CONT;
  1405. }
  1406.  
  1407. /*-
  1408.  * FLY x1 y1 x2 y2 step delay buf [buf] ...
  1409.  * animate a clipping
  1410.  */
  1411. int
  1412. f_fly(ex, ip, nargs)
  1413.     ExecStruct *ex;
  1414.     int         ip;
  1415.     int         nargs;
  1416. {
  1417.     u_short    ithImage;
  1418.     int         x1;
  1419.     int         y1;
  1420.     int         x2;
  1421.     int         y2;
  1422.     int         step;
  1423.     int         d;
  1424.     int         i;
  1425.     int         image;
  1426.     u_short     count;
  1427.     float       x;
  1428.     float       y;
  1429.     float       dx;
  1430.     float       dy;
  1431.     ImageStruct *im;
  1432.  
  1433.     switch (nargs) {
  1434.     case 6:
  1435.     case 5:
  1436.     case 4:
  1437.     case 3:
  1438.     case 2:
  1439.     case 1:
  1440.     case 0:
  1441.     EXEC_ERROR ();
  1442.     break;
  1443.     default:
  1444.         ithImage = intarg(ex, ip + 6);
  1445.         assert (ithImage < 128);
  1446.     im = clipreg[ithImage];
  1447.         assert (im);
  1448.     d = intarg(ex, ip + 5);
  1449.     step = intarg(ex, ip + 4);
  1450.     y2 = intarg(ex, ip + 3);
  1451.     x2 = intarg(ex, ip + 2);
  1452.     y1 = intarg(ex, ip + 1);
  1453.     x1 = intarg(ex, ip);
  1454.     break;
  1455.     }
  1456.  
  1457.     XCopyArea(dsp, im->pix, win, gc, 0, 0, im->w, im->h, x1, YFLIPIM(y1, im));
  1458.  
  1459.     if (x1 == x2 && y1 == y2 ) {
  1460.     for (image = 7; image < nargs; image++) {
  1461.         u_short    ithImage = intarg(ex, ip + image);
  1462.  
  1463.  
  1464.         assert (ithImage < 128);
  1465.         im = clipreg[ithImage];
  1466.         assert (im);
  1467.             XCopyArea(dsp, im->pix, win, gc, 0, 0, im->w, im->h,
  1468.          x1, YFLIPIM(y1, im));
  1469.          XSync(dsp, False);
  1470.         delay(d);
  1471.     }
  1472.     } else {
  1473.     x  = x1;
  1474.     y  = y1;
  1475.     dx = (x2 - x1);
  1476.     dy = (y2 - y1);
  1477.     count = sqrt(dx * dx + dy * dy) / step;
  1478.     dx /= count;
  1479.     dy /= count;
  1480.     image = 7;
  1481.  
  1482.     for (i = 0; i <= count; i++) {
  1483.         if (nargs > 7) {
  1484.         u_short    ithImage = intarg(ex, ip + image);
  1485.  
  1486.  
  1487.         assert (ithImage < 128);
  1488.         im = clipreg[ithImage];
  1489.         assert (im);
  1490.         if (++image == nargs)
  1491.             image = 6;
  1492.         }
  1493.              XCopyArea(dsp, im->pix, win, gc, 0, 0, im->w, im->h,
  1494.          (int) x, YFLIPIM((int) y, im));
  1495.          XSync(dsp, False);
  1496.         x += dx;
  1497.         y += dy;
  1498.         delay(d);
  1499.     }
  1500.     }
  1501.  
  1502.     return CONT;
  1503. }
  1504.  
  1505. /*-
  1506.  * FONT [buffer]
  1507.  * select a font
  1508.  */
  1509. int
  1510. f_font(ex, ip, nargs)
  1511.     ExecStruct *ex;
  1512.     int         ip;
  1513.     int         nargs;
  1514. {
  1515.     switch (nargs) {
  1516.     default:
  1517.     case 1:
  1518.     {
  1519.         u_short    reg = intarg(ex, ip);
  1520.  
  1521.  
  1522.     assert (reg < 16);
  1523.     currentfont = fontreg[reg];
  1524.     break;
  1525.     }
  1526.     case 0:
  1527.     currentfont = fontreg[0];
  1528.     break;
  1529. #if 0
  1530.     default:
  1531.     EXEC_ERROR ();
  1532.     break;
  1533. #endif
  1534.     }
  1535.  
  1536.     return CONT;
  1537. }
  1538.  
  1539. /*-
  1540.  * FSTYLE dir off1 [off2]
  1541.  * set character shading... (I think this changed between 1.1 and 3.0)
  1542.  */
  1543. int
  1544. f_fstyle(ex, ip, nargs)
  1545.     ExecStruct *ex;
  1546.     int         ip;
  1547.     int         nargs;
  1548. {
  1549.     switch (nargs) {
  1550.     default:
  1551.     case 1:
  1552.     case 2:
  1553.     case 3:
  1554.     fstyle = intarg(ex, ip);
  1555.     break;
  1556.     case 0:
  1557.     EXEC_ERROR ();
  1558.     break;
  1559.     }
  1560.  
  1561.     return CONT;
  1562. }
  1563.  
  1564. /*-
  1565.  * GETCOLOR x y
  1566.  * set the drawing color equal to the screen pixel.
  1567.  */
  1568. int
  1569. f_getcolor(ex, ip, nargs)
  1570.     ExecStruct *ex;
  1571.     int         ip;
  1572.     int         nargs;
  1573. {
  1574.     int         x = intarg(ex, ip);
  1575.     int         y = intarg(ex, ip + 1);
  1576.     XImage     *xim;
  1577.  
  1578.     switch (nargs) {
  1579.     default:
  1580.     case 2:
  1581.     y = YFLIP(intarg(ex, ip + 1));
  1582.     x = intarg(ex, ip);
  1583.     break;
  1584.     case 0:
  1585.     case 1:
  1586.     EXEC_ERROR ();
  1587.     break;
  1588.     }
  1589.  
  1590. //    xim = XGetImage(dsp, win, x, YFLIP(y), 1, 1, 0xff, ZPixmap);
  1591. //    currentcolor = XGetPixel(xim, 0, 0);
  1592.     fprintf(stderr,"getcolor %d,%d = %d\n", x, y, currentcolor);
  1593. //    XDestroyImage(xim);
  1594.  
  1595.     return CONT;
  1596. }
  1597.  
  1598. /*-
  1599.  * GETKEY name
  1600.  * set a variable equal to a keystroke
  1601.  */
  1602. int
  1603. f_getkey(ex, ip, nargs)
  1604.     ExecStruct *ex;
  1605.     int         ip;
  1606.     int         nargs;
  1607. {
  1608. #ifdef UNIMPLEMENTED
  1609.     switch (nargs) {
  1610.     default:
  1611.     case 1:
  1612.     break;
  1613.     case 0:
  1614.     EXEC_ERROR ();
  1615.     break;
  1616.     }
  1617. #endif
  1618.  
  1619.     return unimplemented(ex, ip);
  1620. }
  1621.  
  1622. /*-
  1623.  * GOSUB label [val] ...
  1624.  * execute a subroutine
  1625.  */
  1626. int
  1627. f_gosub(ex, ip, nargs)
  1628.     ExecStruct *ex;
  1629.     int         ip;
  1630.     int         nargs;
  1631. {
  1632.     switch (nargs) {
  1633.     default:
  1634.     case 2:
  1635.     case 1:
  1636.     break;
  1637.     case 0:
  1638.     EXEC_ERROR ();
  1639.     break;
  1640.     }
  1641.  
  1642.     ipstack[ipstackptr] = ip + 1;
  1643.     if (++ipstackptr >= STACKSIZE)
  1644.     error("%s: ipstack overflow\n");
  1645.  
  1646.     return intarg(ex, ip);
  1647. }
  1648.  
  1649. /*-
  1650.  * GOTO label
  1651.  * jump to a label
  1652.  */
  1653. int
  1654. f_goto(ex, ip, nargs)
  1655.     ExecStruct *ex;
  1656.     int         ip;
  1657.     int         nargs;
  1658. {
  1659.     switch (nargs) {
  1660.     default:
  1661.     case 1:
  1662.     break;
  1663.     case 0:
  1664.     EXEC_ERROR ();
  1665.     break;
  1666.     }
  1667.  
  1668.     return intarg(ex, ip);
  1669. }
  1670.  
  1671. /*-
  1672.  * IF exp [label]
  1673.  * jump if condition is met, or start if-else block if no label.
  1674.  */
  1675. int
  1676. f_if(ex, ip, nargs)
  1677.     ExecStruct *ex;
  1678.     int         ip;
  1679.     int         nargs;
  1680. {
  1681.     switch (nargs) {
  1682.     default:
  1683.     case 2:
  1684.     case 1:
  1685.     break;
  1686.     case 0:
  1687.     EXEC_ERROR ();
  1688.     break;
  1689.     }
  1690.  
  1691.     return unimplemented(ex, ip);
  1692. }
  1693.  
  1694. /*-
  1695.  * IFKEY key [label [key label] ... ]
  1696.  * check for specific keypress
  1697.  */
  1698. int
  1699. f_ifkey(ex, ip, nargs)
  1700.     ExecStruct *ex;
  1701.     int         ip;
  1702.     int         nargs;
  1703. {
  1704.     int         i;
  1705.  
  1706.     switch (nargs) {
  1707.     case 0:
  1708.     EXEC_ERROR ();
  1709.     break;
  1710.     default:
  1711.     break;
  1712.     }
  1713.  
  1714.     for (i = 0; i < nargs; i += 2) {
  1715.     char       *key = strarg(ex, ip + i);
  1716.     if (*key == keypressed)
  1717.         return intarg(ex, ip + i + 1);
  1718.     }
  1719.  
  1720.     return CONT;
  1721. }
  1722.  
  1723. /*-
  1724.  * IFMEM mem [label]
  1725.  * check available memory.
  1726.  */
  1727. int
  1728. f_ifmem(ex, ip, nargs)
  1729.     ExecStruct *ex;
  1730.     int         ip;
  1731.     int         nargs;
  1732. {
  1733.     /* ignore the memory value */
  1734.  
  1735.     int         label;
  1736.  
  1737.     switch (nargs) {
  1738.     default:
  1739.     case 2:
  1740.     label = intarg(ex, ip + 1);
  1741.         break;
  1742.     case 1:
  1743.     label = CONT;
  1744.     break;
  1745.     case 0:
  1746.     EXEC_ERROR ();
  1747.     break;
  1748.     }
  1749.  
  1750.     return label;
  1751. }
  1752.  
  1753. /*-
  1754.  * IFMOUSE button [label1] [x y x1 y1] [color] [wait] [label2]
  1755.  * check for a mouse click (no idea how this one is supposed to work).
  1756.  */
  1757. int
  1758. f_ifmouse(ex, ip, nargs)
  1759.     ExecStruct *ex;
  1760.     int         ip;
  1761.     int         nargs;
  1762. {
  1763. #ifdef UNIMPLEMENTED
  1764.     switch (nargs) {
  1765.     default:
  1766.     case 9:
  1767.     case 8:
  1768.     case 7:
  1769.     case 6:
  1770.     case 2:
  1771.     case 1:
  1772.     break;
  1773.     case 0:
  1774.     case 3:
  1775.     case 4:
  1776.     case 5:
  1777.     EXEC_ERROR ();
  1778.     break;
  1779.     }
  1780. #endif
  1781.  
  1782.     return unimplemented(ex, ip);
  1783. }
  1784.  
  1785. /*-
  1786.  * IFVIDEO mode [label]
  1787.  * check whether video mode is available
  1788.  */
  1789. int
  1790. f_ifvideo(ex, ip, nargs)
  1791.     ExecStruct *ex;
  1792.     int         ip;
  1793.     int         nargs;
  1794. {
  1795.     int         label;
  1796.  
  1797.     switch (nargs) {
  1798.     default:
  1799.     case 2:
  1800.     label = intarg(ex, ip + 1);
  1801.     break;
  1802.     case 1:
  1803.     label = CONT;
  1804.     break;
  1805.     case 0:
  1806.     EXEC_ERROR ();
  1807.     break;
  1808.     }
  1809.  
  1810.     return label;
  1811. }
  1812.  
  1813. /*-
  1814.  * INT num [ax] [bx] [cx] [dx] [si] [di] [ds] [es]
  1815.  * call an MSDOS interrupt... (yeah, right!)
  1816.  */
  1817. int
  1818. f_int(ex, ip, nargs)
  1819.     ExecStruct *ex;
  1820.     int         ip;
  1821.     int         nargs;
  1822. {
  1823. #ifdef UNIMPLEMENTED
  1824.     switch (nargs) {
  1825.     default:
  1826.     case 9:
  1827.     case 8:
  1828.     case 7:
  1829.     case 6:
  1830.     case 5:
  1831.     case 4:
  1832.     case 3:
  1833.     case 2:
  1834.     case 1:
  1835.     break;
  1836.     case 0:
  1837.     EXEC_ERROR ();
  1838.     break;
  1839.     }
  1840. #endif
  1841.  
  1842.     return unimplemented(ex, ip);
  1843. }
  1844.  
  1845. static int  linex1 = 0;
  1846. static int  liney1 = 0;
  1847. static int  linex2 = 0;
  1848. static int  liney2 = 0;
  1849.  
  1850. /*-
  1851.  * LINE x1 y1 x2 y2 [R]
  1852.  * draw a line, (possibly relative to the current point).
  1853.  */
  1854. int
  1855. f_line(ex, ip, nargs)
  1856.     ExecStruct *ex;
  1857.     int         ip;
  1858.     int         nargs;
  1859. {
  1860.     switch (nargs) {
  1861.     default:
  1862.     case 5:
  1863.     linex1 += intarg(ex, ip);
  1864.     liney1 += intarg(ex, ip + 1);
  1865.     linex2 += intarg(ex, ip + 2);
  1866.     liney2 += intarg(ex, ip + 3);
  1867.     break;
  1868.     case 4:
  1869.     linex1 = intarg(ex, ip);
  1870.     liney1 = intarg(ex, ip + 1);
  1871.     linex2 = intarg(ex, ip + 2);
  1872.     liney2 = intarg(ex, ip + 3);
  1873.     break;
  1874.     case 0:
  1875.     case 1:
  1876.     case 2:
  1877.     case 3:
  1878.     EXEC_ERROR ();
  1879.     break;
  1880.     }
  1881.  
  1882.     XSetForeground(dsp, gc, currentcolor);
  1883.     XDrawLine (dsp, win, gc,
  1884.                linex1 + xOffset, YFLIP(liney1 + yOffset),
  1885.                linex2 + xOffset, YFLIP(liney2 + yOffset));
  1886.     XSync(dsp, False);
  1887.  
  1888.     return CONT;
  1889. }
  1890.  
  1891. /*-
  1892.  * LINK name [label]
  1893.  * jump to another program
  1894.  */
  1895. int
  1896. f_link(ex, ip, nargs)
  1897.     ExecStruct *ex;
  1898.     int         ip;
  1899.     int         nargs;
  1900. {
  1901.     int         label;
  1902.  
  1903.     switch (nargs) {
  1904.     default:
  1905.     case 2:
  1906.     label = intarg(ex, ip + 1);
  1907.     break;
  1908.     case 1:
  1909.     label = 0;
  1910.     break;
  1911.     case 0:
  1912.     EXEC_ERROR ();
  1913.     break;
  1914.     }
  1915.  
  1916.     execfile(excarg(ex, ip), label);
  1917.  
  1918.     return DONE;
  1919. }
  1920.  
  1921. /*-
  1922.  * LOCAL var value
  1923.  * define a local variable
  1924.  */
  1925. int
  1926. f_local(ex, ip, nargs)
  1927.     ExecStruct *ex;
  1928.     int         ip;
  1929.     int         nargs;
  1930. {
  1931. #ifdef UNIMPLEMENTED
  1932.     switch (nargs) {
  1933.     default:
  1934.     case 2:
  1935.     break;
  1936.     case 0:
  1937.     case 1:
  1938.     EXEC_ERROR ();
  1939.     break;
  1940.     }
  1941. #endif
  1942.  
  1943.     return unimplemented(ex, ip);
  1944. }
  1945.  
  1946. /*-
  1947.  * LOOP
  1948.  * define the end of a MARK'ed loop.
  1949.  */
  1950. int
  1951. f_loop(ex, ip, nargs)
  1952.     ExecStruct *ex;
  1953.     int         ip;
  1954.     int         nargs;
  1955. {
  1956.     switch (nargs) {
  1957.     case 0:
  1958.     break;
  1959. #if 0
  1960.     default:
  1961.     EXEC_ERROR ();
  1962.     break;
  1963. #endif
  1964.     }
  1965.  
  1966.     if (--loopstack[loopstackptr - 1].count == 0) {
  1967.     --loopstackptr;
  1968.  
  1969.     return CONT;
  1970.     }
  1971.  
  1972.     return loopstack[loopstackptr - 1].ipaddr;
  1973. }
  1974.  
  1975. /*-
  1976.  * MARK count [rand]
  1977.  * define the beginning of a loop. (not sure what rand is supposed to do.)
  1978.  */
  1979. int
  1980. f_mark(ex, ip, nargs)
  1981.     ExecStruct *ex;
  1982.     int         ip;
  1983.     int         nargs;
  1984. {
  1985.     switch (nargs) {
  1986.     default:
  1987.     case 2:
  1988.     case 1:
  1989.     break;
  1990.     case 0:
  1991.     EXEC_ERROR ();
  1992.     break;
  1993.     }
  1994.  
  1995.     loopstack[loopstackptr].count = intarg(ex, ip);
  1996.     loopstack[loopstackptr].ipaddr = ip + 1;
  1997.     if (++loopstackptr >= STACKSIZE)
  1998.     error("%s: stack overflow\n");
  1999.  
  2000.     return CONT;
  2001. }
  2002.  
  2003. /*-
  2004.  * MERGE name
  2005.  * add lines to the current program from another
  2006.  * (why is this different from CALL?)
  2007.  */
  2008. int
  2009. f_merge(ex, ip, nargs)
  2010.     ExecStruct *ex;
  2011.     int         ip;
  2012.     int         nargs;
  2013. {
  2014. #ifdef UNIMPLEMENTED
  2015.     switch (nargs) {
  2016.     default:
  2017.     case 1:
  2018.     break;
  2019.     case 0:
  2020.     EXEC_ERROR ();
  2021.     break;
  2022.     }
  2023. #endif
  2024.  
  2025.     return unimplemented(ex, ip);
  2026. }
  2027.  
  2028. /*-
  2029.  * MODE color
  2030.  * change colors in 2 color CGA mode.
  2031.  */
  2032. int
  2033. f_mode(ex, ip, nargs)
  2034.     ExecStruct *ex;
  2035.     int         ip;
  2036.     int         nargs;
  2037. {
  2038.     int         color;
  2039.     int         pal = 0;
  2040.     int         i;
  2041.     u_long      pmasks;
  2042.     u_long      pixels[4];
  2043.     ImageStruct *im = picreg[0];
  2044.  
  2045.     switch (nargs) {
  2046.     default:
  2047.     case 1:
  2048.     color = intarg(ex, ip);
  2049.     break;
  2050.     case 0:
  2051.     EXEC_ERROR ();
  2052.     break;
  2053.     }
  2054.  
  2055. #if 0
  2056.     assert (im);
  2057.  
  2058.     im->cmaplen = 4;
  2059.     if (nargs > 1)
  2060.     pal = intarg(ex, ip + 1);
  2061.  
  2062.     if (!im->cmap) {
  2063.      im->cmap = XCreateColormap(dsp, win, vis, AllocNone);
  2064.      XAllocColorCells(dsp, im->cmap, True, (unsigned long *) &pmasks, 0,
  2065.                       (unsigned long *) pixels, im->cmaplen);
  2066.     }
  2067.     i = 0;
  2068.     im->colors[i].pixel = i;
  2069.     im->colors[i].red = egapal[color][0];
  2070.     im->colors[i].green = egapal[color][1];
  2071.     im->colors[i].blue = egapal[color][2];
  2072.     im->colors[i].flags = DoRed | DoGreen | DoBlue;
  2073.  
  2074.     for (i = 1; i < 4; i++) {
  2075.     color = cgapal[i - 1][pal];
  2076.     im->colors[i].pixel = i;
  2077.     im->colors[i].red = egapal[color][0];
  2078.     im->colors[i].green = egapal[color][1];
  2079.     im->colors[i].blue = egapal[color][2];
  2080.     im->colors[i].flags = DoRed | DoGreen | DoBlue;
  2081.     }
  2082.     XStoreColors(dsp, im->cmap, im->colors, im->cmaplen);
  2083.     installcmap(0);
  2084. #endif
  2085.  
  2086.     return CONT;
  2087. }
  2088.  
  2089. /*-
  2090.  * MOUSE setting
  2091.  * turn mouse on/off
  2092.  */
  2093. int
  2094. f_mouse(ex, ip, nargs)
  2095.     ExecStruct *ex;
  2096.     int         ip;
  2097.     int         nargs;
  2098. {
  2099. #ifdef UNIMPLEMENTED
  2100.     switch (nargs) {
  2101.     default:
  2102.     case 1:
  2103.     break;
  2104.     case 0:
  2105.     EXEC_ERROR ();
  2106.     break;
  2107.     }
  2108. #endif
  2109.  
  2110.     return unimplemented(ex, ip);
  2111. }
  2112.  
  2113. /*-
  2114.  * MOVE x1 y1 x2 y2 x3 y3
  2115.  * move an area of the screen
  2116.  */
  2117. int
  2118. f_move(ex, ip, nargs)
  2119.     ExecStruct *ex;
  2120.     int         ip;
  2121.     int         nargs;
  2122. {
  2123.     int         x1;
  2124.     int         y1;
  2125.     int         x2;
  2126.     int         y2;
  2127.     int         w;
  2128.     int         h;
  2129.     int         x3;
  2130.     int         y3;
  2131.  
  2132.     switch (nargs) {
  2133.     default:
  2134.     case 6:
  2135.     x1 = intarg(ex, ip);
  2136.     y1 = YFLIP(intarg(ex, ip + 1));
  2137.     x2 = intarg(ex, ip + 2);
  2138.     y2 = YFLIP(intarg(ex, ip + 3));
  2139.     w = x2 - x1;
  2140.     h = y2 - y1;
  2141.     x3 = intarg(ex, ip + 4);
  2142.     y3 = YFLIP(intarg(ex, ip + 5)) - h;
  2143.     break;
  2144.     case 0:
  2145.     case 1:
  2146.     case 2:
  2147.     case 3:
  2148.     case 4:
  2149.     case 5:
  2150.     EXEC_ERROR ();
  2151.     break;
  2152.     }
  2153.  
  2154. //    XCopyArea(dsp, win, win, gc, x1, y1, w, h, x3, y3);
  2155.  
  2156.     return CONT;
  2157. }
  2158.  
  2159. /*-
  2160.  * NOISE n m time
  2161.  * create a sound
  2162.  */
  2163. int
  2164. f_noise(ex, ip, nargs)
  2165.     ExecStruct *ex;
  2166.     int         ip;
  2167.     int         nargs;
  2168. {
  2169.     /* NOP */
  2170.     switch (nargs) {
  2171.     default:
  2172.     case 3:
  2173.     break;
  2174.     case 0:
  2175.     case 1:
  2176.     case 2:
  2177.     EXEC_ERROR ();
  2178.     break;
  2179.     }
  2180.  
  2181.     return unimplemented(ex, ip);
  2182. }
  2183.  
  2184. /*-
  2185.  * NOTE val tone time [R]
  2186.  * play a note
  2187.  */
  2188. int
  2189. f_note(ex, ip, nargs)
  2190.     ExecStruct *ex;
  2191.     int         ip;
  2192.     int         nargs;
  2193. {
  2194.     /* NOP */
  2195.     switch (nargs) {
  2196.     default:
  2197.     case 4:
  2198.     case 3:
  2199.     break;
  2200.     case 0:
  2201.     case 1:
  2202.     case 2:
  2203.     EXEC_ERROR ();
  2204.     break;
  2205.     }
  2206.  
  2207.     return unimplemented(ex, ip);
  2208. }
  2209.  
  2210. /*-
  2211.  * OFFSET x y [R]
  2212.  * change the screen coords for some other commands.
  2213.  */
  2214. int
  2215. f_offset(ex, ip, nargs)
  2216.     ExecStruct *ex;
  2217.     int         ip;
  2218.     int         nargs;
  2219. {
  2220. #ifdef UNIMPLEMENTED
  2221.     switch (nargs) {
  2222.     default:
  2223.     case 3:
  2224.     case 2:
  2225.     yOffset = intarg (ex, ip + 1);
  2226.     xOffset = intarg (ex, ip);
  2227.     break;
  2228.     case 0:
  2229.     case 1:
  2230.     EXEC_ERROR ();
  2231.     break;
  2232.     }
  2233. #endif
  2234.  
  2235.     return unimplemented(ex, ip);
  2236. }
  2237.  
  2238. /*-
  2239.  * OPENGL name
  2240.  * use files in a library file.
  2241.  */
  2242. int
  2243. f_opengl(ex, ip, nargs)
  2244.     ExecStruct *ex;
  2245.     int         ip;
  2246.     int         nargs;
  2247. {
  2248. #ifdef UNIMPLEMENTED
  2249.     switch (nargs) {
  2250.     default:
  2251.     case 1:
  2252.     break;
  2253.     case 0:
  2254.     EXEC_ERROR ();
  2255.     break;
  2256.     }
  2257. #endif
  2258.  
  2259.     return unimplemented(ex, ip);
  2260. }
  2261.  
  2262. /*-
  2263.  * OUT dx al [ah]
  2264.  * output a value to an IBM PC hardware I/O port (yeah, right!)
  2265.  */
  2266. int
  2267. f_out(ex, ip, nargs)
  2268.     ExecStruct *ex;
  2269.     int         ip;
  2270.     int         nargs;
  2271. {
  2272. #ifdef UNIMPLEMENTED
  2273.     switch (nargs) {
  2274.     default:
  2275.     case 3:
  2276.     case 2:
  2277.     break;
  2278.     case 0:
  2279.     case 1:
  2280.     EXEC_ERROR ();
  2281.     break;
  2282.     }
  2283. #endif
  2284.  
  2285.     return unimplemented(ex, ip);
  2286. }
  2287.  
  2288. /*-
  2289.  * PALETTE buffer
  2290.  * set palette colors to match a given picture.
  2291.  */
  2292. int
  2293. f_palette(ex, ip, nargs)
  2294.     ExecStruct *ex;
  2295.     int         ip;
  2296.     int         nargs;
  2297. {
  2298.     int         cmap;
  2299.  
  2300.     switch (nargs) {
  2301.     default:
  2302.     case 1:
  2303.     cmap = intarg(ex, ip);
  2304.     break;
  2305.     case 0:
  2306.     EXEC_ERROR ();
  2307.     break;
  2308.     }
  2309.  
  2310.     installcmap(cmap);
  2311.  
  2312.     return CONT;
  2313. }
  2314.  
  2315. /*-
  2316.  * PAN [x1 y1] x2 y2 [R] [speed]
  2317.  * pan across large picture in EGA mode.
  2318.  */
  2319. int
  2320. f_pan(ex, ip, nargs)
  2321.     ExecStruct *ex;
  2322.     int         ip;
  2323.     int         nargs;
  2324. {
  2325. #ifdef UNIMPLEMENTED
  2326.     switch (nargs) {
  2327.     case 1:
  2328.     break;
  2329.     default:
  2330.     EXEC_ERROR ();
  2331.     break;
  2332.     }
  2333. #endif
  2334.  
  2335.     return unimplemented(ex, ip);
  2336. }
  2337.  
  2338. /*-
  2339.  * PFADE fade [buffer] [speed] [delay]
  2340.  * display a picture.
  2341.  */
  2342. int
  2343. f_pfade(ex, ip, nargs)
  2344.     ExecStruct *ex;
  2345.     int         ip;
  2346.     int         nargs;
  2347. {
  2348.     int         fadestyle;
  2349.     u_short     buf = 0;
  2350.     int         speed = 0;
  2351.     int         d = 10;
  2352.     ImageStruct *im;
  2353.  
  2354.     switch (nargs) {
  2355.     default:
  2356.     case 4:
  2357.     d = (int) resolvewild(ex, ip + 3, INTEGER);
  2358.     case 3:
  2359.     speed = (int) resolvewild(ex, ip + 2, INTEGER);
  2360.     case 2:
  2361.     buf = (int) resolvewild(ex, ip + 1, INTEGER);
  2362.     case 1:
  2363.     fadestyle = (int) resolvewild(ex, ip, INTEGER);
  2364.     break;
  2365.     case 0:
  2366.     EXEC_ERROR ();
  2367.     }
  2368.  
  2369.     assert (buf < PICREGSIZE);
  2370.     im = picreg[buf];
  2371.  
  2372.     if (buf == 0) {
  2373.        assert (im);
  2374.     XSetForeground(dsp, gc, currentcolor);
  2375.     XFillRectangle(dsp, im->pix, gc, 0, 0, im->w, im->h);
  2376.     }
  2377.  
  2378.     if (im)
  2379.     imagefade(fadestyle, im, 0, 0, speed, 1);
  2380.  
  2381.     delay(d);
  2382.  
  2383.     return CONT;
  2384. }
  2385.  
  2386. /*-
  2387.  * PFREE buffer [buffer] ...
  2388.  * unload a picture.
  2389.  */
  2390. int
  2391. f_pfree(ex, ip, nargs)
  2392.     ExecStruct *ex;
  2393.     int         ip;
  2394.     int         nargs;
  2395. {
  2396.     /* NOP */
  2397.     switch (nargs) {
  2398.     case 0:
  2399.     EXEC_ERROR ();
  2400.     break;
  2401.     default:
  2402.     break;
  2403.     }
  2404.  
  2405.     return CONT;
  2406. }
  2407.  
  2408. /*-
  2409.  * PGETBUF n [x1 y1 x2 y2]
  2410.  * copy the screen into a picture buffer, (same as CGETBUF?)
  2411.  */
  2412. int
  2413. f_pgetbuf(ex, ip, nargs)
  2414.     ExecStruct *ex;
  2415.     int         ip;
  2416.     int         nargs;
  2417. {
  2418. #ifdef UNIMPLEMENTED
  2419.     switch (nargs) {
  2420.     default:
  2421.     case 5:
  2422.     case 1:
  2423.     break;
  2424.     case 0:
  2425.     case 2:
  2426.     case 3:
  2427.     case 4:
  2428.     EXEC_ERROR ();
  2429.     break;
  2430.     }
  2431. #endif
  2432.  
  2433.     return unimplemented(ex, ip);
  2434. }
  2435.  
  2436. /*-
  2437.  * PLOAD name [buffer]
  2438.  * load a picture.
  2439.  */
  2440. int
  2441. f_pload(ex, ip, nargs)
  2442.     ExecStruct *ex;
  2443.     int         ip;
  2444.     int         nargs;
  2445. {
  2446.     ImageStruct *im;
  2447.     u_short      regnum;
  2448.  
  2449.     switch (nargs) {
  2450.     default:
  2451.     case 2:
  2452.     im = imgarg(ex, ip);
  2453.     regnum = intarg(ex, ip + 1);
  2454.     break;
  2455.     case 1:
  2456.     im = imgarg(ex, ip);
  2457.     regnum = 1;
  2458.     break;
  2459.     case 0:
  2460.     EXEC_ERROR ();
  2461.     break;
  2462.     }
  2463.  
  2464.     assert (regnum < PICREGSIZE);
  2465.     picreg[regnum] = im;
  2466.  
  2467.     lastRegnum = regnum;
  2468.  
  2469.     return CONT;
  2470. }
  2471.  
  2472. /*-
  2473.  * PNEWBUF buffer [x y]
  2474.  * create an empty picture buffer. (what is x, y? offset?)
  2475.  */
  2476. int
  2477. f_pnewbuf(ex, ip, nargs)
  2478.     ExecStruct *ex;
  2479.     int         ip;
  2480.     int         nargs;
  2481. {
  2482. #ifdef UNIMPLEMENTED
  2483.     switch (nargs) {
  2484.     case 3:
  2485.     case 1:
  2486.     break;
  2487.     default:
  2488.     EXEC_ERROR ();
  2489.     break;
  2490.     }
  2491. #endif
  2492.  
  2493.     return unimplemented(ex, ip);
  2494. }
  2495.  
  2496. /*-
  2497.  * POINT x y [rx ry]
  2498.  * draw a point (what are rx,ry?)
  2499.  */
  2500. int
  2501. f_point(ex, ip, nargs)
  2502.     ExecStruct *ex;
  2503.     int         ip;
  2504.     int         nargs;
  2505. {
  2506.     int         x;
  2507.     int         y;
  2508.  
  2509.     switch (nargs) {
  2510.     default:
  2511.     case 4:
  2512.     case 2:
  2513.     x = intarg(ex, ip) + xOffset;
  2514.     y = YFLIP(intarg(ex, ip + 1) + yOffset);
  2515.     break;
  2516.     case 0:
  2517.     case 1:
  2518.     case 3:
  2519.     EXEC_ERROR ();
  2520.     break;
  2521.     }
  2522.  
  2523.     XSetForeground(dsp, gc, currentcolor);
  2524.     XDrawPoint(dsp, win, gc, x, y);
  2525.     XSync(dsp, False);
  2526.  
  2527.     return CONT;
  2528. }
  2529.  
  2530. /*-
  2531.  * POKE seg off byte [byte] ...
  2532.  * change 8-bit memory given 8088 seg:off address (yeah, right!)
  2533.  */
  2534. int
  2535. f_poke(ex, ip, nargs)
  2536.     ExecStruct *ex;
  2537.     int         ip;
  2538.     int         nargs;
  2539. {
  2540. #ifdef UNIMPLEMENTED
  2541.     switch (nargs) {
  2542.     case 2:
  2543.     case 1:
  2544.     EXEC_ERROR ();
  2545.     break;
  2546.     default:
  2547.     break;
  2548.     }
  2549. #endif
  2550.  
  2551.     return unimplemented(ex, ip);
  2552. }
  2553.  
  2554. /*-
  2555.  * POKEL seg off byte [byte] ...
  2556.  * change 32-bit memory given 8088 seg:off address (yeah, right!)
  2557.  */
  2558. int
  2559. f_pokel(ex, ip, nargs)
  2560.     ExecStruct *ex;
  2561.     int         ip;
  2562.     int         nargs;
  2563. {
  2564. #ifdef UNIMPLEMENTED
  2565.     switch (nargs) {
  2566.     case 2:
  2567.     case 1:
  2568.     EXEC_ERROR ();
  2569.     break;
  2570.     default:
  2571.     break;
  2572.     }
  2573. #endif
  2574.  
  2575.     return unimplemented(ex, ip);
  2576. }
  2577.  
  2578. /*-
  2579.  * POKEW seg off byte [byte] ...
  2580.  * change 16-bit memory given 8088 seg:off address (yeah, right!)
  2581.  */
  2582. int
  2583. f_pokew(ex, ip, nargs)
  2584.     ExecStruct *ex;
  2585.     int         ip;
  2586.     int         nargs;
  2587. {
  2588. #ifdef UNIMPLEMENTED
  2589.     switch (nargs) {
  2590.     case 2:
  2591.     case 1:
  2592.     EXEC_ERROR ();
  2593.     break;
  2594.     default:
  2595.     break;
  2596.     }
  2597. #endif
  2598.  
  2599.     return unimplemented(ex, ip);
  2600. }
  2601.  
  2602. /*-
  2603.  * POP label
  2604.  * leave a subroutine and branch on return.
  2605.  */
  2606. int
  2607. f_pop(ex, ip, nargs)
  2608.     ExecStruct *ex;
  2609.     int         ip;
  2610.     int         nargs;
  2611. {
  2612. #ifdef UNIMPLEMENTED
  2613.     switch (nargs) {
  2614.     case 1:
  2615.     break;
  2616.     default:
  2617.     EXEC_ERROR ();
  2618.     break;
  2619.     }
  2620. #endif
  2621.  
  2622.     return unimplemented(ex, ip);
  2623. }
  2624.  
  2625. /*-
  2626.  * POSITION buffer x y [R]
  2627.  * alter picture placement on the screen.
  2628.  */
  2629. int
  2630. f_position(ex, ip, nargs)
  2631.     ExecStruct *ex;
  2632.     int         ip;
  2633.     int         nargs;
  2634. {
  2635.     u_short     buf;
  2636.     ImageStruct *pIm;
  2637.     int         x = intarg(ex, ip + 1);
  2638.     int         y = intarg(ex, ip + 2);
  2639.     int         rel = 0;
  2640.  
  2641.     assert (buf < 128);
  2642.  
  2643.     switch (nargs) {
  2644.     default:
  2645.     case 4:
  2646.     case 3:
  2647.     buf = intarg(ex, ip);
  2648.     assert (buf < PICREGSIZE);
  2649.     assert (pIm = picreg[buf] /* != (ImageStruct *) NULL */);
  2650.     if (nargs == 3)
  2651.     {
  2652.         pIm->xoff = intarg(ex, ip + 1);
  2653.         pIm->yoff = intarg(ex, ip + 2);
  2654.     }
  2655.     else
  2656.     {
  2657.         pIm->xoff += intarg(ex, ip + 1);
  2658.         pIm->yoff += intarg(ex, ip + 2);
  2659.     }
  2660.     break;
  2661.     case 0:
  2662.     case 1:
  2663.     case 2:
  2664.     EXEC_ERROR ();
  2665.     break;
  2666.     }
  2667.  
  2668.     return CONT;
  2669. }
  2670.  
  2671. /*-
  2672.  * PSAVE name [buffer]
  2673.  * save picture buffer to disk.
  2674.  */
  2675. int
  2676. f_psave(ex, ip, nargs)
  2677.     ExecStruct *ex;
  2678.     int         ip;
  2679.     int         nargs;
  2680. {
  2681. #ifdef UNIMPLEMENTED
  2682.     switch (nargs) {
  2683.     case 2:
  2684.     case 1:
  2685.     break;
  2686.     default:
  2687.     EXEC_ERROR ();
  2688.     break;
  2689.     }
  2690. #endif
  2691.  
  2692.     return unimplemented(ex, ip);
  2693. }
  2694.  
  2695. /*-
  2696.  * PSETBUF [buffer]
  2697.  * draw to picture buffer instead of screen.
  2698.  */
  2699. int
  2700. f_psetbuf(ex, ip, nargs)
  2701.     ExecStruct *ex;
  2702.     int         ip;
  2703.     int         nargs;
  2704. {
  2705. #ifdef UNIMPLEMENTED
  2706.     switch (nargs) {
  2707.     case 1:
  2708.     case 0:
  2709.     break;
  2710.     default:
  2711.     EXEC_ERROR ();
  2712.     break;
  2713.     }
  2714. #endif
  2715.  
  2716.     return unimplemented(ex, ip);
  2717. }
  2718.  
  2719. /*-
  2720.  * PUTDFF [buffer] [delay] [start] [end] [x y]
  2721.  * play a differential animation file.
  2722.  */
  2723. int
  2724. f_putdff(ex, ip, nargs)
  2725.     ExecStruct *ex;
  2726.     int         ip;
  2727.     int         nargs;
  2728. {
  2729. #ifdef UNIMPLEMENTED
  2730.     switch (nargs) {
  2731.     case 5:
  2732.     case 4:
  2733.     case 3:
  2734.     case 2:
  2735.     case 1:
  2736.     case 0:
  2737.     break;
  2738.     default:
  2739.     EXEC_ERROR ();
  2740.     break;
  2741.     }
  2742. #endif
  2743.  
  2744.     return unimplemented(ex, ip);
  2745. }
  2746.  
  2747. /*-
  2748.  * PUTUP x y [buffer] [delay]
  2749.  * display a clipping
  2750.  */
  2751. int
  2752. f_putup(ex, ip, nargs)
  2753.     ExecStruct *ex;
  2754.     int         ip;
  2755.     int         nargs;
  2756. {
  2757.     int         x = (int) resolvewild(ex, ip, INTEGER);
  2758.     int         y = (int) resolvewild(ex, ip + 1, INTEGER);
  2759.     u_short     clip = (int) resolvewild(ex, ip + 2, INTEGER);
  2760.     ImageStruct *im;
  2761.     int         d = 1;
  2762.  
  2763.     assert (clip < 128);
  2764.     im = clipreg[clip];
  2765.     assert (im);
  2766.  
  2767.     switch (nargs) {
  2768.     default:
  2769.     case 4:
  2770.     d = intarg(ex, ip + 3);
  2771.     case 3:
  2772.     clip = (int) resolvewild(ex, ip + 2, INTEGER);
  2773.     y = (int) resolvewild(ex, ip + 1, INTEGER);
  2774.     x = (int) resolvewild(ex, ip, INTEGER);
  2775.     break;
  2776.     case 0:
  2777.     case 1:
  2778.     case 2:
  2779.     EXEC_ERROR ();
  2780.     break;
  2781.     }
  2782.  
  2783.  
  2784.     x += im->xoff;
  2785.     y += im->yoff;
  2786.     XCopyArea(dsp, im->pix, win, gc, 0, 0, im->w, im->h, x, YFLIPIM(y, im));
  2787.     XSync(dsp, False);
  2788.     delay(d);
  2789.     return CONT;
  2790. }
  2791.  
  2792. /*-
  2793.  * RECT x1 y1 x2 y2
  2794.  * draw a filled rectangle;
  2795.  */
  2796. int
  2797. f_rect(ex, ip, nargs)
  2798.     ExecStruct *ex;
  2799.     int         ip;
  2800.     int         nargs;
  2801. {
  2802.     int         x1;
  2803.     int         y1;
  2804.     int         x2;
  2805.     int         y2;
  2806.  
  2807.     switch (nargs) {
  2808.     default:
  2809.     case 4:
  2810.     x1 = intarg(ex, ip);
  2811.     y1 = intarg(ex, ip + 1);
  2812.     x2 = intarg(ex, ip + 2);
  2813.     y2 = intarg(ex, ip + 3);
  2814.     break;
  2815.     case 0:
  2816.     case 1:
  2817.     case 2:
  2818.     case 3:
  2819.     EXEC_ERROR ();
  2820.     break;
  2821.     }
  2822.  
  2823.     XSetForeground(dsp, gc, currentcolor);
  2824.     XFillRectangle(dsp, win, gc, x1, YFLIP(y2), x2 - x1, y2 - y1);
  2825.  
  2826.     return CONT;
  2827. }
  2828.  
  2829. /*-
  2830.  * RESETGL
  2831.  * close a library
  2832.  */
  2833. int
  2834. f_resetgl(ex, ip, nargs)
  2835.     ExecStruct *ex;
  2836.     int         ip;
  2837.     int         nargs;
  2838. {
  2839. #ifdef UNIMPLEMENTED
  2840.     switch (nargs) {
  2841.     case 0:
  2842.     break;
  2843.     default:
  2844.     EXEC_ERROR ();
  2845.     break;
  2846.     }
  2847. #endif
  2848.  
  2849.     return unimplemented(ex, ip);
  2850. }
  2851.  
  2852. /*-
  2853.  * RESETSCR
  2854.  * reset normal screen size.
  2855.  */
  2856. int
  2857. f_resetscr(ex, ip, nargs)
  2858.     ExecStruct *ex;
  2859.     int         ip;
  2860.     int         nargs;
  2861. {
  2862. #ifdef UNIMPLEMENTED
  2863.     switch (nargs) {
  2864.     case 0:
  2865.     break;
  2866.     default:
  2867.     EXEC_ERROR ();
  2868.     break;
  2869.     }
  2870. #endif
  2871.  
  2872.     return unimplemented(ex, ip);
  2873. }
  2874.  
  2875. /*-
  2876.  * RETURN [val]
  2877.  * return from a subroutine.
  2878.  */
  2879. int
  2880. f_return(ex, ip, nargs)
  2881.     ExecStruct *ex;
  2882.     int         ip;
  2883.     int         nargs;
  2884. {
  2885.     switch (nargs) {
  2886.     case 1:
  2887.     case 0:
  2888.     break;
  2889. #if 0
  2890.     default:
  2891.     EXEC_ERROR ();
  2892.     break;
  2893. #endif
  2894.     }
  2895.  
  2896.     if (--ipstackptr < 0)
  2897.     error("%s: ipstack underflow\n");
  2898.  
  2899.     return ipstack[ipstackptr];
  2900. }
  2901.  
  2902. /*-
  2903.  * REVPAGE
  2904.  * reverse viewing and drawing pages (for double buffering?)
  2905.  */
  2906. int
  2907. f_revpage(ex, ip, nargs)
  2908.     ExecStruct *ex;
  2909.     int         ip;
  2910.     int         nargs;
  2911. {
  2912. #ifdef UNIMPLEMENTED
  2913.     switch (nargs) {
  2914.     case 0:
  2915.     break;
  2916.     default:
  2917.     EXEC_ERROR ();
  2918.     break;
  2919.     }
  2920. #endif
  2921.  
  2922.     return unimplemented(ex, ip);
  2923. }
  2924.  
  2925. /*-
  2926.  * SEND device string
  2927.  * send a character string to a device (yeah, right!)
  2928.  */
  2929. int
  2930. f_send(ex, ip, nargs)
  2931.     ExecStruct *ex;
  2932.     int         ip;
  2933.     int         nargs;
  2934. {
  2935. #ifdef UNIMPLEMENTED
  2936.     switch (nargs) {
  2937.     case 2:
  2938.     break;
  2939.     default:
  2940.     EXEC_ERROR ();
  2941.     break;
  2942.     }
  2943. #endif
  2944.  
  2945.     return unimplemented(ex, ip);
  2946. }
  2947.  
  2948. /*-
  2949.  * SET function|feature|var value
  2950.  * alter system characteristics or alter text features or defines variables...
  2951.  */
  2952. int
  2953. f_set(ex, ip, nargs)
  2954.     ExecStruct *ex;
  2955.     int         ip;
  2956.     int         nargs;
  2957. {
  2958. #ifdef UNIMPLEMENTED
  2959.     switch (nargs) {
  2960.     case 2:
  2961.     break;
  2962.     default:
  2963.     EXEC_ERROR ();
  2964.     break;
  2965.     }
  2966. #endif
  2967.  
  2968.     return unimplemented(ex, ip);
  2969. }
  2970.  
  2971. /*-
  2972.  * SETCOLOR val0 val1 val2 ... val16
  2973.  * define palette in EGA mode
  2974.  */
  2975. int
  2976. f_setcolor(ex, ip, nargs)
  2977.     ExecStruct *ex;
  2978.     int         ip;
  2979.     int         nargs;
  2980. {
  2981.     int         i;
  2982.     u_long      pmasks;
  2983.     u_long      pixels[16];
  2984.     ImageStruct *im = picreg[0];
  2985.  
  2986.  
  2987.     if (nargs < 16)
  2988.     error("%s: not 16 args to setcolor\n");
  2989.  
  2990.     assert (im);
  2991.  
  2992.     im->cmaplen = nargs;
  2993.  
  2994.     if (!im->cmap) {
  2995.     im->cmap = XCreateColormap(dsp, win, vis, AllocNone);
  2996.     XAllocColorCells(dsp, im->cmap, True, (unsigned long *) &pmasks,
  2997.                      0, (unsigned long *) pixels, im->cmaplen);
  2998.     }
  2999.  
  3000.     for (i = 0; i < im->cmaplen; i++)
  3001.     {
  3002.     int         pal = intarg(ex, ip + i);
  3003.     im->colors[i].pixel = i;
  3004.     im->colors[i].red = decodepal(pal, 0x20, 0x04) << 8;
  3005.     im->colors[i].green = decodepal(pal, 0x10, 0x02) << 8;
  3006.     im->colors[i].blue = decodepal(pal, 0x08, 0x01) << 8;
  3007.     im->colors[i].flags = DoRed | DoGreen | DoBlue;
  3008.     }
  3009.  
  3010.     XStoreColors(dsp, im->cmap, im->colors, im->cmaplen);
  3011.     installcmap(0);
  3012.  
  3013.     return CONT;
  3014. }
  3015.  
  3016. /*-
  3017.  * SETPAGE view draw
  3018.  * define viewing and drawing pages for double buffering.
  3019.  */
  3020. int
  3021. f_setpage(ex, ip, nargs)
  3022.     ExecStruct *ex;
  3023.     int         ip;
  3024.     int         nargs;
  3025. {
  3026. #ifdef UNIMPLEMENTED
  3027.     switch (nargs) {
  3028.     case 2:
  3029.     break;
  3030.     default:
  3031.     EXEC_ERROR ();
  3032.     break;
  3033.     }
  3034. #endif
  3035.  
  3036.     return unimplemented(ex, ip);
  3037. }
  3038.  
  3039. /*-
  3040.  * SETRGB start r g b [R] rand
  3041.  * change color in VGA mode (not sure what R or rand do...)
  3042.  */
  3043. int
  3044. f_setrgb(ex, ip, nargs)
  3045.     ExecStruct *ex;
  3046.     int         ip;
  3047.     int         nargs;
  3048. {
  3049.     int         start;
  3050.     int         r;
  3051.     int         g;
  3052.     int         b;
  3053.     XColor      c;
  3054.     ImageStruct *pIm;
  3055.     XColor     *pColors;
  3056.  
  3057.     switch (nargs) {
  3058.     default:
  3059.     case 6:
  3060.     case 5:
  3061.     case 4:
  3062.     start = intarg(ex, ip);
  3063.     r = intarg(ex, ip + 1);
  3064.     g = intarg(ex, ip + 2);
  3065.     b = intarg(ex, ip + 3);
  3066.     break;
  3067.     case 0:
  3068.     case 1:
  3069.     case 2:
  3070.     case 3:
  3071.     EXEC_ERROR ();
  3072.     break;
  3073.     }
  3074.  
  3075.     assert (pIm = picreg[palettenum] /* != (ImageStruct *) NULL */);
  3076.     assert (pColors = pIm->colors /* != (XColor *) NULL */);
  3077.  
  3078.     c.pixel = pColors[start].pixel;
  3079.     c.red = r << 8;
  3080.     c.green = g << 8;
  3081.     c.blue = b << 8;
  3082.     c.flags = DoRed | DoGreen | DoBlue;
  3083.  
  3084.     if (installedcmap == (Colormap) NULL)
  3085.     {
  3086.     if (lastRegnum == -1)
  3087.         return CONT;
  3088.     else
  3089.         installcmap (lastRegnum);
  3090.     }
  3091.  
  3092.     if (installedcmap /* != (Colormap) NULL */)
  3093.     XStoreColors (dsp, installedcmap, &c, 1);
  3094.  
  3095.     return CONT;
  3096. }
  3097.  
  3098. /*-
  3099.  * SETUPSCR buffer
  3100.  * create a virtual screen for panning.
  3101.  */
  3102. int
  3103. f_setupscr(ex, ip, nargs)
  3104.     ExecStruct *ex;
  3105.     int         ip;
  3106.     int         nargs;
  3107. {
  3108. #ifdef UNIMPLEMENTED
  3109.     switch (nargs) {
  3110.     default:
  3111.     case 1:
  3112.     break;
  3113.     case 0:
  3114.     EXEC_ERROR ();
  3115.     break;
  3116.     }
  3117. #endif
  3118.  
  3119.     return unimplemented(ex, ip);
  3120. }
  3121.  
  3122. /*-
  3123.  * SPLIT line [R]
  3124.  * divide an EGA screen into two independant areas.
  3125.  */
  3126. int
  3127. f_split(ex, ip, nargs)
  3128.     ExecStruct *ex;
  3129.     int         ip;
  3130.     int         nargs;
  3131. {
  3132. #ifdef UNIMPLEMENTED
  3133.     switch (nargs) {
  3134.     default:
  3135.     case 2:
  3136.     case 1:
  3137.     break;
  3138.     case 0:
  3139.     EXEC_ERROR ();
  3140.     break;
  3141.     }
  3142. #endif
  3143.  
  3144.     return unimplemented(ex, ip);
  3145. }
  3146.  
  3147.  
  3148. #define lerp(a,b,step,nsteps)                \
  3149. ((a)<(b)                        \
  3150.     ? (a) + ((b) - (a)) * (step) / (nsteps)        \
  3151.     : (b) + ((a) - (b)) * (step) / (nsteps))
  3152.  
  3153.  
  3154. /*-
  3155.  * SPREAD [pal1] pal2 [steps]
  3156.  * cross-fade between two VGA palettes.
  3157.  */
  3158. int
  3159. f_spread(ex, ip, nargs)
  3160.     ExecStruct *ex;
  3161.     int         ip;
  3162.     int         nargs;
  3163. {
  3164.     u_short      r1;
  3165.     u_short      r2;
  3166.     ImageStruct *p1;
  3167.     ImageStruct *p2;
  3168.     int         n = 1;
  3169.     XColor      colors[256];
  3170.     int         i;
  3171.     int         j;
  3172.     Colormap    cmap;
  3173.     unsigned long pmasks;
  3174.     unsigned long pixels[256];
  3175.     int         len;
  3176.  
  3177.     switch (nargs) {
  3178.     default:
  3179.     case 3:
  3180.     n = intarg(ex, ip + 2);
  3181.     case 2:
  3182.     r2 = intarg(ex, ip + 1);
  3183.     r1 = intarg(ex, ip);
  3184.     assert (r1 < PICREGSIZE);
  3185.     assert (r2 < PICREGSIZE);
  3186.     p2 = picreg[r2];
  3187.     p1 = picreg[r1];
  3188.     assert (p1);
  3189.     assert (p2);
  3190.     break;
  3191.     case 0:
  3192.     case 1:
  3193.     EXEC_ERROR ();
  3194.     break;
  3195.     }
  3196.  
  3197.     n = (n < 0) ? -n : n;
  3198.  
  3199.     len = p1->cmaplen;
  3200.  
  3201.     if (len != p2->cmaplen)
  3202.     error("%s: %d,%d spread length mismatch\n", len, p2->cmaplen);
  3203.  
  3204.     cmap = XCreateColormap(dsp, win, vis, AllocNone);
  3205.     XAllocColorCells(dsp, cmap, True, &pmasks, 0, pixels, len);
  3206.     for (i = 0; i < len; i++) {
  3207.     colors[i].pixel = pixels[i];
  3208.     colors[i].red = p1->colors[i].red;
  3209.     colors[i].green = p1->colors[i].green;
  3210.     colors[i].blue = p1->colors[i].blue;
  3211.     colors[i].flags = DoRed | DoGreen | DoBlue;
  3212.     }
  3213.     XStoreColors(dsp, cmap, p1->colors, p1->cmaplen);
  3214.     XSetWindowColormap(dsp, win, cmap);
  3215.  
  3216.     for (j = 1; j <= n; j++) {
  3217.     for (i = 0; i < len; i++) {
  3218.         XColor     *c1 = &(p1->colors[i]);
  3219.         XColor     *c2 = &(p2->colors[i]);
  3220.         colors[i].red = lerp(c1->red, c2->red, j, n);
  3221.         colors[i].green = lerp(c1->green, c2->green, j, n);
  3222.         colors[i].red = lerp(c1->red, c2->red, j, n);
  3223.     }
  3224.     XStoreColors(dsp, cmap, colors, p1->cmaplen);
  3225.     XSync(dsp, False);
  3226.     }
  3227.     installcmap(r2);
  3228.     XFreeColormap(dsp, cmap);
  3229.     XSync(dsp, False);
  3230.  
  3231.     return -1;
  3232. }
  3233.  
  3234. void
  3235. displaystring(s, x, y)
  3236.     char       *s;
  3237.     int         x, y;
  3238. {
  3239.     int         i;
  3240.  
  3241.  
  3242.     if (verbose)
  3243.     fprintf (stderr, "Text: \"%s\"\n", s);
  3244.  
  3245.     {
  3246.         GrafPtr        oldPort;
  3247.         Rect        aRect;
  3248.         FontInfo    fInfo;
  3249.  
  3250.  
  3251.     GetPort (&oldPort);
  3252.     SetPort ((WindowPtr) dsp);
  3253.     TextSize (currentfont->height);
  3254.  
  3255.     MoveTo (x, y);
  3256.     TextMode (srcOr);
  3257.     DrawText (s, 0, strlen (s));
  3258.     SetPort (oldPort);
  3259.     }
  3260.  
  3261. #if 0
  3262.     for (i = 0; i < strlen(s); i++)
  3263.     {
  3264.      GlyphStruct *g = ¤tfont->glyphs[s[i]];
  3265.  
  3266.      if (g->pix)
  3267.      {
  3268.          XSetStipple(dsp, gc, g->pix);
  3269.          XSetTSOrigin(dsp, gc, x - g->lbearing, y);
  3270. /*****
  3271.          XFillRectangle(dsp, win, gc, x, y, g->width, currentfont->height);
  3272. ******/
  3273.          x += g->width + chargap;
  3274.      }
  3275.     }
  3276. #endif
  3277. }
  3278.  
  3279. /*-
  3280.  * TEXT [x y] string [delay]
  3281.  * print characters on the screen.
  3282.  */
  3283. int
  3284. f_text(ex, ip, nargs)
  3285.     ExecStruct *ex;
  3286.     int         ip;
  3287.     int         nargs;
  3288. {
  3289.     int         x;
  3290.     int         y;
  3291.     char        *s;
  3292.     int         d = 1;
  3293.     int         i;
  3294.  
  3295.  
  3296.     switch (nargs) {
  3297.     default:
  3298.     case 4:
  3299.     d = intarg(ex, ip + 3);
  3300.     case 3:
  3301.     s = strarg(ex, ip + 2);
  3302.     y = intarg(ex, ip + 1);
  3303.     x = intarg(ex, ip);
  3304.     break;
  3305.     case 0:
  3306.     case 1:
  3307.     case 2:
  3308.     EXEC_ERROR ();
  3309.     break;
  3310.     }
  3311.  
  3312.     if (!currentfont) {
  3313.     /* hack there should be a default font. */
  3314.     XSetForeground(dsp, gc, currentcolor);
  3315.     XSetBackground(dsp, gc, currentbgcolor);
  3316.     XDrawString(dsp, win, gc, x, YFLIP(y), s, strlen(s));
  3317.     goto text_exit;
  3318.     }
  3319.     currentfont->glyphs[' '].width = spacegap;
  3320.     y = YFLIP(y) - currentfont->height - 2;
  3321.     XSetFillStyle(dsp, gc, FillStippled);
  3322.     XSetForeground(dsp, gc, (fstyle > 2) ? currentbgcolor : currentcolor);
  3323.     switch (fstyle) {
  3324.     case 0:
  3325.     break;
  3326.     case 1:
  3327.     displaystring(s, x, y - 1);    /* bold up */
  3328.     break;
  3329.     case 2:
  3330.     displaystring(s, x + 1, y);    /* bold right */
  3331.     break;
  3332.     case 3:
  3333.     displaystring(s, x + 1, y - 1);    /* shadow up right */
  3334.     break;
  3335.     case 4:
  3336.     displaystring(s, x - 1, y - 1);    /* shadow up left */
  3337.     break;
  3338.     case 5:
  3339.     displaystring(s, x + 2, y - 2);    /* shadow up right 2 pixels */
  3340.     break;
  3341.     case 6:
  3342.     displaystring(s, x - 2, y - 2);    /* shadow up left 2 pixels */
  3343.     break;
  3344.     default:
  3345.     break;
  3346.     }
  3347.     XSetForeground(dsp, gc, currentcolor);
  3348.     displaystring(s, x, y);
  3349.     XSetFillStyle(dsp, gc, FillSolid);
  3350.  
  3351. text_exit:
  3352.     XSync(dsp, False);
  3353.     delay(d);
  3354.  
  3355.     return CONT;
  3356. }
  3357.  
  3358. /*-
  3359.  * TILE buffer [bleed]
  3360.  * fill screen with copies of the clipping.
  3361.  */
  3362. int
  3363. f_tile(ex, ip, nargs)
  3364.     ExecStruct *ex;
  3365.     int         ip;
  3366.     int         nargs;
  3367. {
  3368.     ImageStruct *im;
  3369.     int         x;
  3370.     int         y;
  3371.  
  3372.     switch (nargs) {
  3373.     default:
  3374.     case 2:
  3375.     case 1:
  3376.     {
  3377.     u_short    ithImage = intarg(ex, ip);
  3378.  
  3379.  
  3380.     assert (ithImage < 128);
  3381.     im = clipreg[ithImage];
  3382.     assert (im);
  3383.     break;
  3384.     }
  3385.     case 0:
  3386.     EXEC_ERROR ();
  3387.     break;
  3388.     }
  3389.  
  3390.     assert (picreg[0]);
  3391.  
  3392.     for (y = 0; y <= picreg[0]->h - im->h; y += im->h)
  3393.     for (x = 0; x <= picreg[0]->w - im->w; x += im->w)
  3394.         XCopyArea(dsp, im->pix, win, gc, 0, 0, im->w, im->h, x, y);
  3395.     delay(10);
  3396.  
  3397.     return CONT;
  3398. }
  3399.  
  3400. /*-
  3401.  * TIMER
  3402.  * set the system clock for execution timing (huh?)
  3403.  */
  3404. int
  3405. f_timer(ex, ip, nargs)
  3406.     ExecStruct *ex;
  3407.     int         ip;
  3408.     int         nargs;
  3409. {
  3410. #ifdef UNIMPLEMENTED
  3411.     switch (nargs) {
  3412.     case 0:
  3413.     break;
  3414.     default:
  3415.     EXEC_ERROR ();
  3416.     break;
  3417.     }
  3418. #endif
  3419.  
  3420.     return unimplemented(ex, ip);
  3421. }
  3422.  
  3423. /*-
  3424.  * TRAN set [color ...]
  3425.  * set = "on"|"off", make color be transparent in clippings.
  3426.  */
  3427. int
  3428. f_tran(ex, ip, nargs)
  3429.     ExecStruct *ex;
  3430.     int         ip;
  3431.     int         nargs;
  3432. {
  3433.     int         tranval;
  3434.  
  3435.     switch (nargs) {
  3436.     default:
  3437.     case 1:
  3438.     tranval = intarg(ex, ip);
  3439.     break;
  3440.     case 0:
  3441.     EXEC_ERROR ();
  3442.     break;
  3443.     }
  3444.  
  3445.     return -1;
  3446. }
  3447.  
  3448. /*-
  3449.  * VIDEO mode [x y] [init]
  3450.  * set the display mode (not sure what x and y and init are for)
  3451.  */
  3452. int
  3453. f_video(ex, ip, nargs)
  3454.     ExecStruct *ex;
  3455.     int         ip;
  3456.     int         nargs;
  3457. {
  3458.     char        *s;
  3459.     char        c;
  3460.  
  3461.     switch (nargs) {
  3462.     default:
  3463.     case 4:
  3464.     case 3:
  3465.     case 1:
  3466.     s = strarg(ex, ip);
  3467.     c = s[0];
  3468.     break;
  3469.     case 0:
  3470.     case 2:
  3471.     EXEC_ERROR ();
  3472.     break;
  3473.     }
  3474.  
  3475.     setvideomode(c);
  3476.  
  3477.     return CONT;
  3478. }
  3479.  
  3480.  
  3481. /*-
  3482.  * WAITKEY [time] [label]
  3483.  * wait for a keystroke or a given time, and jump to label on timeout.
  3484.  */
  3485. int
  3486. f_waitkey(ex, ip, nargs)
  3487.     ExecStruct *ex;
  3488.     int         ip;
  3489.     int         nargs;
  3490. {
  3491.     long        endtime = 0;
  3492.     int         retaddr = CONT;
  3493.     char    fHaveTime;
  3494.  
  3495.     switch (nargs) {
  3496.     default:
  3497.     case 2:
  3498.     retaddr = intarg(ex, ip + 1);
  3499.     case 1:
  3500.     endtime = hundredthsofseconds() + intarg(ex, ip);
  3501.     fHaveTime = 1;
  3502.     break;
  3503.     case 0:
  3504.         fHaveTime = 0;
  3505.     break;
  3506. #if 0
  3507.     default:
  3508.     EXEC_ERROR ();
  3509.     break;
  3510. #endif
  3511.     }
  3512.  
  3513.     while (1)
  3514.     {
  3515.     exitcheck();
  3516.     usleep(10000);    /* sleep for 1/100th of a second */
  3517.     if (MouseButton() || Keypress(&keypressed))
  3518.         return retaddr;
  3519.     if (fHaveTime && (hundredthsofseconds() > endtime))
  3520.         return retaddr;
  3521.     }
  3522. }
  3523.  
  3524.  
  3525. /*-
  3526.  * WHEN key [command]
  3527.  * set up an automatic response for given keystroke.
  3528.  */
  3529. int
  3530. f_when(ex, ip, nargs)
  3531.     ExecStruct *ex;
  3532.     int         ip;
  3533.     int         nargs;
  3534. {
  3535. #ifdef UNIMPLEMENTED
  3536.     switch (nargs) {
  3537.     case 2:
  3538.     case 1:
  3539.     break;
  3540.     default:
  3541.     EXEC_ERROR ();
  3542.     break;
  3543.     }
  3544. #endif
  3545.  
  3546.     return unimplemented(ex, ip);
  3547. }
  3548.  
  3549. /*-
  3550.  * WINDOW x1 y1 x2 y2 [R]
  3551.  * limit screen changes to given area.
  3552.  */
  3553. int
  3554. f_window(ex, ip, nargs)
  3555.     ExecStruct *ex;
  3556.     int         ip;
  3557.     int         nargs;
  3558. {
  3559.     int         offset_x;
  3560.     int         offset_y;
  3561.  
  3562.     switch (nargs) {
  3563.     default:
  3564.     case 5: // relative
  3565.     {
  3566.     offset_x = window.x;
  3567.     offset_y = YFLIP(window.y) - window.height;
  3568.     window.x = intarg(ex, ip);
  3569.     window.y = intarg(ex, ip + 1);
  3570.     window.width  = intarg(ex, ip + 2) - window.x + 1;
  3571.     window.height = intarg(ex, ip + 3) - window.y + 1;
  3572.     window.x = window.x + offset_x;
  3573.     window.y = YFLIP(intarg(ex, ip + 3) + offset_y);
  3574.     break;
  3575.     }
  3576.     case 4: // absolute
  3577.     window.x = intarg(ex, ip);
  3578.     window.y = intarg(ex, ip + 1);
  3579.     window.width  = intarg(ex, ip + 2) - window.x + 1;
  3580.     window.height = intarg(ex, ip + 3) - window.y + 1;
  3581.     window.y = YFLIP(intarg(ex, ip + 3));
  3582.     break;
  3583.     case 0: // restore default
  3584.     window.x = 0;
  3585.     window.y = 0;
  3586.     assert (picreg[0]);
  3587.     window.width  = picreg[0]->w;
  3588.     window.height = picreg[0]->h;
  3589.     break;
  3590.     case 1:
  3591.     case 2:
  3592.     case 3:
  3593.     EXEC_ERROR ();
  3594.     }
  3595.  
  3596.     if (videomode == 'c')
  3597.     {
  3598.         window.height <<= 1;
  3599.         window.y      <<= 1;
  3600.     }
  3601.  
  3602.     return CONT;
  3603. }
  3604.  
  3605. int         (*funcs[]) () = {
  3606.     0,
  3607.     f_box,
  3608.     f_break,
  3609.     f_call,
  3610.     f_cfade,
  3611.     f_cfree,
  3612.     f_cgetbuf,
  3613.     f_chgcolor,
  3614.     f_circle,
  3615.     f_clearscr,
  3616.     f_cload,
  3617.     f_closegl,
  3618.     f_color,
  3619.     f_cycle,
  3620.     f_data,
  3621.     f_databegin,
  3622.     f_dataend,
  3623.     f_dataskip,
  3624.     f_dfree,
  3625.     f_dload,
  3626.     f_edge,
  3627.     f_else,
  3628.     f_endlfloat,
  3629.     f_endif,
  3630.     f_exec,
  3631.     f_exit,
  3632.     f_ffree,
  3633.     f_fgaps,
  3634.     f_fload,
  3635.     f_float,
  3636.     f_fly,
  3637.     f_font,
  3638.     f_fstyle,
  3639.     f_getcolor,
  3640.     f_getkey,
  3641.     f_gosub,
  3642.     f_goto,
  3643.     f_if,
  3644.     f_ifkey,
  3645.     f_ifmem,
  3646.     f_ifmouse,
  3647.     f_ifvideo,
  3648.     f_int,
  3649.     f_line,
  3650.     f_link,
  3651.     f_local,
  3652.     f_loop,
  3653.     f_mark,
  3654.     f_merge,
  3655.     f_mode,
  3656.     f_mouse,
  3657.     f_move,
  3658.     f_noise,
  3659.     f_note,
  3660.     f_offset,
  3661.     f_opengl,
  3662.     f_out,
  3663.     f_palette,
  3664.     f_pan,
  3665.     f_pfade,
  3666.     f_pfree,
  3667.     f_pgetbuf,
  3668.     f_pload,
  3669.     f_pnewbuf,
  3670.     f_point,
  3671.     f_poke,
  3672.     f_pokel,
  3673.     f_pokew,
  3674.     f_pop,
  3675.     f_position,
  3676.     f_psave,
  3677.     f_psetbuf,
  3678.     f_putdff,
  3679.     f_putup,
  3680.     f_rect,
  3681.     f_resetgl,
  3682.     f_resetscr,
  3683.     f_return,
  3684.     f_revpage,
  3685.     f_send,
  3686.     f_set,
  3687.     f_setcolor,
  3688.     f_setpage,
  3689.     f_setrgb,
  3690.     f_setupscr,
  3691.     f_split,
  3692.     f_spread,
  3693.     f_text,
  3694.     f_tile,
  3695.     f_timer,
  3696.     f_tran,
  3697.     f_video,
  3698.     f_waitkey,
  3699.     f_when,
  3700.     f_window,
  3701.     f_pfade,
  3702.     f_waitkey
  3703. };
  3704.  
  3705.  
  3706. void
  3707. printexec(ex, nargs)
  3708.     ExecStruct *ex;
  3709.     int         nargs;
  3710. {
  3711.     int         i;
  3712.  
  3713.     fprintf(stderr,"executing: %s", tokens[ex->Code[ex->ip].token]);
  3714.     for (i = 1; i <= nargs; i++)
  3715.     switch (ex->Code[ex->ip + i].token) {
  3716.     case STRING:
  3717.         fprintf(stderr," %s", ex->Code[ex->ip + i].val.s);
  3718.         break;
  3719.     case INTEGER:
  3720.         fprintf(stderr," %d", ex->Code[ex->ip + i].val.i);
  3721.         break;
  3722.     case IMAGE:
  3723.         fprintf(stderr," %s", ex->Code[ex->ip + i].val.image->name);
  3724.         break;
  3725.     case FONTTYPE:
  3726.         if (ex->Code[ex->ip + i].val.font)
  3727.         fprintf(stderr," %s", ex->Code[ex->ip + i].val.font->name);
  3728.         else
  3729.         fprintf(stderr," (nil)");
  3730.         break;
  3731.     case EXECTYPE:
  3732.         fprintf(stderr," %s", ex->Code[ex->ip + i].val.exec->name);
  3733.         break;
  3734.     case WILDTYPE:
  3735.         fprintf(stderr," @");
  3736.         break;
  3737.     default:
  3738.         error("%s: bogus token type.\n");
  3739.     }
  3740.     fprintf(stderr,"\n");
  3741. }
  3742.  
  3743.  
  3744. void
  3745. execfile(ex, ip)
  3746.     ExecStruct *ex;
  3747.     int         ip;
  3748. {
  3749.     ex->ip = ip;
  3750.     ex->currentdataptr = -1;
  3751.     ex->currentdataend = -1;
  3752.  
  3753.     while (1)
  3754.     {
  3755.     int         nargs = ex->Code[ex->ip].val.i;
  3756.     int         i = ex->Code[ex->ip].token;
  3757.     int         retval;
  3758.  
  3759.     if (i > NTOKENS) {
  3760.         fprintf(stderr,"skipping bogus token %s\n", ex->Code[ex->ip].val.s);
  3761.         ex->ip++;
  3762.         continue;
  3763.     }
  3764.  
  3765.     if (verbose)
  3766.         printexec(ex, nargs);
  3767.  
  3768.     switch (retval = funcs[i] (ex, ex->ip + 1, nargs)) {
  3769.     case DONE:
  3770.         return;
  3771.     case ESCAPE:
  3772.         exit(0);
  3773.     case CONT:
  3774.         if ((ex->ip += (nargs + 1)) >= ex->numcodes)
  3775.         return;
  3776.         break;
  3777.     default:
  3778.         ex->ip = retval;
  3779.     }
  3780.     exitcheck();
  3781.     }
  3782. }
  3783.